Merge pull request 'Release v26.04.08.2 — Knowledge consolidation + Modern Fable identity' (#25 ) from dev into main

feat: narrator empty states, scroll fades, glow buttons, violet color sweep
feat(knowledge): card type DNA, violet hover bloom, amber timestamps, narrator empty states
2026-04-08 15:40:12 +00:00 · 2026-04-08 11:17:06 -04:00 · 2026-04-08 11:14:31 -04:00 · 2026-04-08 11:11:35 -04:00 · 2026-04-08 11:09:23 -04:00 · 2026-04-08 10:43:20 -04:00
40 changed files with 4217 additions and 1861 deletions
@@ -0,0 +1,479 @@
 # Web Voice Overlay Polish — 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:** Ship the dormant `VoiceOverlay` component by mounting it in `App.vue`, wiring the Space bar shortcut, and replacing push-to-talk with click-to-toggle silence detection backed by a new `useSilenceDetector` composable.
 **Architecture:** A new `useSilenceDetector` composable uses `AudioContext` + `AnalyserNode` to monitor amplitude from a live `MediaStream` and fires a callback after sustained silence. `VoiceOverlay` coordinates recording and silence detection, switching from hold-to-record to click-to-toggle. `App.vue` mounts the overlay and adds a Space bar handler that dispatches the existing `voice:ptt-toggle` custom event.
 **Tech Stack:** Vue 3 Composition API, TypeScript, Web Audio API (`AudioContext`, `AnalyserNode`), existing `useVoiceRecorder` / `useVoiceAudio` composables.
 ---
 ## File Map
 | Action | Path |
 |--------|------|
 | Create | `frontend/src/composables/useSilenceDetector.ts` |
 | Modify | `frontend/src/composables/useVoiceRecorder.ts` |
 | Modify | `frontend/src/components/VoiceOverlay.vue` |
 | Modify | `frontend/src/App.vue` |
 ---
 ### Task 1: `useSilenceDetector` composable
 **Files:**
 - Create: `frontend/src/composables/useSilenceDetector.ts`
 **Context:** The Web Audio API lets us pipe a `MediaStream` into an `AnalyserNode` and read frequency data as a byte array every 100 ms. RMS amplitude of that array gives a 0–1 loudness value; converting to dB lets us use the same `-40 dB` threshold as the Android app. The composable must be safe to call `stop()` on multiple times and must reset amplitude to 0 after stopping so the animated bars collapse.
 - [ ] **Step 1: Create the file with full implementation**
 `frontend/src/composables/useSilenceDetector.ts`:
 ```ts
 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()
    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 }
 }
 ```
 - [ ] **Step 2: Verify TypeScript compiles**
 ```bash
 cd /path/to/fabledassistant/frontend
 npx tsc --noEmit
 ```
 Expected: no errors.
 - [ ] **Step 3: Commit**
 ```bash
 git add frontend/src/composables/useSilenceDetector.ts
 git commit -m "feat: add useSilenceDetector composable with Web Audio API amplitude monitoring"
 ```
 ---
 ### Task 2: Expose `stream` ref from `useVoiceRecorder`
 **Files:**
 - Modify: `frontend/src/composables/useVoiceRecorder.ts`
 **Context:** Currently `stream` is a plain `let` variable inside the closure. `VoiceOverlay` needs to pass the live `MediaStream` to `useSilenceDetector.start()` after recording begins. Exposing it as a readonly `Ref<MediaStream | null>` is the minimal change — no other callers are broken because they don't currently read `stream` from the return value.
 The current file is at `frontend/src/composables/useVoiceRecorder.ts`. Read it before editing — the key lines to change are:
 1. Top of function body: `let stream: MediaStream | null = null` → `const streamRef = ref<MediaStream | null>(null)`
 2. In `startRecording()`: `stream = await navigator.mediaDevices.getUserMedia({ audio: true })` → `streamRef.value = await navigator.mediaDevices.getUserMedia({ audio: true })`
 3. In `startRecording()` catch block: `stream = null` if present — replace with `streamRef.value = null` (if the catch sets stream to null; if not, skip)
 4. In `mediaRecorder.onstop`: `stream?.getTracks().forEach((t) => t.stop())` → `streamRef.value?.getTracks().forEach((t) => t.stop())` then `streamRef.value = null`
 5. Return object: add `stream: readonly(streamRef)`
 - [ ] **Step 1: Add the `ref` import if not already present**
 The file already imports `{ ref, readonly }` from `'vue'` — confirm this. If `ref` is missing from the import, add it.
 - [ ] **Step 2: Replace the `stream` variable declaration**
 Find:
 ```ts
 let stream: MediaStream | null = null
 ```
 Replace with:
 ```ts
 const streamRef = ref<MediaStream | null>(null)
 ```
 - [ ] **Step 3: Update all usages of `stream` in `startRecording`**
 Find:
 ```ts
      stream = await navigator.mediaDevices.getUserMedia({ audio: true })
 ```
 Replace with:
 ```ts
      streamRef.value = await navigator.mediaDevices.getUserMedia({ audio: true })
 ```
 - [ ] **Step 4: Update `onstop` handler**
 Find:
 ```ts
      stream?.getTracks().forEach((t) => t.stop())
      stream = null
 ```
 Replace with:
 ```ts
      streamRef.value?.getTracks().forEach((t) => t.stop())
      streamRef.value = null
 ```
 - [ ] **Step 5: Add `stream` to the return object**
 Find the return statement and add `stream: readonly(streamRef)`:
 ```ts
  return {
    recording: readonly(recording),
    error: readonly(error),
    isSupported,
    startRecording,
    stopRecording,
    stream: readonly(streamRef),
  }
 ```
 - [ ] **Step 6: Verify TypeScript compiles**
 ```bash
 npx tsc --noEmit
 ```
 Expected: no errors.
 - [ ] **Step 7: Commit**
 ```bash
 git add frontend/src/composables/useVoiceRecorder.ts
 git commit -m "feat: expose live stream ref from useVoiceRecorder"
 ```
 ---
 ### Task 3: Update `VoiceOverlay` — silence detection, click-to-toggle, amplitude bars
 **Files:**
 - Modify: `frontend/src/components/VoiceOverlay.vue`
 **Context:** `VoiceOverlay.vue` is a complete floating voice UI that was never mounted. It currently uses `@mousedown`/`@mouseup` for push-to-talk. This task switches it to click-to-toggle with automatic silence detection and adds animated amplitude bars during recording. Read the full file before making changes — the existing structure and style blocks must be preserved.
 #### Script changes
 - [ ] **Step 1: Import `useSilenceDetector`**
 At the top of `<script setup>`, after the existing imports, add:
 ```ts
 import { useSilenceDetector } from '@/composables/useSilenceDetector'
 ```
 - [ ] **Step 2: Instantiate the composable**
 After `const audio = useVoiceAudio()`, add:
 ```ts
 const silenceDetector = useSilenceDetector()
 ```
 - [ ] **Step 3: Update `startPtt` to start silence detection**
 Find the `startPtt` function. After `phase.value = 'recording'`, add:
 ```ts
  if (recorder.stream.value) {
    silenceDetector.start(recorder.stream.value, stopPtt)
  }
 ```
 The complete `startPtt` after the change:
 ```ts
 async function startPtt() {
  if (!voiceEnabled.value || isBusy.value) return
  audio.stop()
  errorMsg.value = ''
  open.value = true
  await recorder.startRecording()
  if (recorder.error.value) {
    phase.value = 'error'
    errorMsg.value = recorder.error.value
    return
  }
  phase.value = 'recording'
  if (recorder.stream.value) {
    silenceDetector.start(recorder.stream.value, stopPtt)
  }
 }
 ```
 - [ ] **Step 4: Update `stopPtt` to stop silence detection**
 Add `silenceDetector.stop()` as the very first line of `stopPtt`:
 ```ts
 async function stopPtt() {
  silenceDetector.stop()
  if (phase.value !== 'recording') return
  // ... rest unchanged
 ```
 - [ ] **Step 5: Update `cancelAll` to stop silence detection**
 Add `silenceDetector.stop()` after `recorder.stopRecording().catch(() => {})`:
 ```ts
 function cancelAll() {
  silenceDetector.stop()
  recorder.stopRecording().catch(() => {})
  audio.stop()
  phase.value = 'idle'
  streamContent.value = ''
  errorMsg.value = ''
 }
 ```
 - [ ] **Step 6: Add `onBtnClick` function**
 Add this function after `cancelAll`:
 ```ts
 function onBtnClick() {
  if (phase.value === 'error') { phase.value = 'idle'; return }
  if (phase.value === 'recording') { stopPtt(); return }
  if (phase.value === 'idle') { startPtt() }
 }
 ```
 #### Template changes
 - [ ] **Step 7: Replace PTT mouse/touch handlers with `@click`**
 On `.voice-ptt-btn`, replace:
 ```html
@mousedown.prevent="startPtt"
@mouseup.prevent="stopPtt"
@touchstart.prevent="startPtt"
@touchend.prevent="stopPtt"
@click.prevent="phase === 'error' ? (phase = 'idle') : undefined"
 ```
 with:
 ```html
@click.prevent="onBtnClick"
 ```
 - [ ] **Step 8: Update aria-label and title on the button**
 Replace:
 ```html
 :aria-label="phase === 'recording' ? 'Release to send' : 'Hold to speak'"
 :title="phase === 'recording' ? 'Release to send' : 'Hold Space or tap to speak'"
 ```
 with:
 ```html
 :aria-label="phase === 'recording' ? 'Click to stop' : 'Click to speak'"
 :title="phase === 'recording' ? 'Click to stop or wait for silence' : 'Click or press Space to speak'"
 ```
 - [ ] **Step 9: Replace the static recording icon with amplitude bars**
 Find:
 ```html
          <!-- Recording: waveform / stop icon -->
          <svg v-else-if="phase === 'recording'" width="22" height="22" viewBox="0 0 24 24" fill="currentColor">
            <path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/>
          </svg>
 ```
 Replace with:
 ```html
          <!-- Recording: amplitude bars -->
          <span v-else-if="phase === 'recording'" class="voice-amp-bars">
            <span
              v-for="n in 3"
              :key="n"
              class="voice-amp-bar"
              :style="{ transform: `scaleY(${0.3 + silenceDetector.amplitude.value * (0.4 + n * 0.15)})` }"
            ></span>
          </span>
 ```
 - [ ] **Step 10: Update the idle hint label**
 Find:
 ```html
          Hold <kbd>Space</kbd> or tap
 ```
 Replace with:
 ```html
          Tap or press <kbd>Space</kbd>
 ```
 #### Style changes
 - [ ] **Step 11: Add amplitude bar styles to `<style scoped>`**
 Append inside the `<style scoped>` block:
 ```css
 /* ─── Amplitude bars (recording state) ──────────────────────────────────── */
 .voice-amp-bars {
  display: flex;
  gap: 3px;
  align-items: center;
  height: 22px;
 }
 .voice-amp-bar {
  width: 4px;
  height: 18px;
  background: #fff;
  border-radius: 2px;
  transform-origin: center;
  transition: transform 0.08s ease;
 }
 ```
 - [ ] **Step 12: Verify TypeScript compiles**
 ```bash
 npx tsc --noEmit
 ```
 Expected: no errors.
 - [ ] **Step 13: Commit**
 ```bash
 git add frontend/src/components/VoiceOverlay.vue
 git commit -m "feat: click-to-toggle silence detection and amplitude bars in VoiceOverlay"
 ```
 ---
 ### Task 4: Mount `VoiceOverlay` and wire Space bar in `App.vue`
 **Files:**
 - Modify: `frontend/src/App.vue`
 **Context:** `App.vue` has a full `onGlobalKeydown` handler and a shortcuts overlay. The Space bar is already documented there as "Hold to speak (voice, when enabled)" but the handler was never added to `onGlobalKeydown`. `VoiceOverlay` uses `Teleport to="body"` so it renders at the document root regardless of where it's placed in the template — just needs to be inside the authenticated block.
 #### Script changes
 - [ ] **Step 1: Add `VoiceOverlay` import**
 In `<script setup>`, after the existing component imports (after `ToastNotification`), add:
 ```ts
 import VoiceOverlay from '@/components/VoiceOverlay.vue'
 ```
 - [ ] **Step 2: Add Space bar case to `onGlobalKeydown`**
 The existing handler has a `switch (e.key)` block. The guard `if (isInputActive() || e.ctrlKey || e.metaKey || e.altKey) return` already runs before the switch, so the Space case only fires when the user isn't typing.
 Inside the `switch (e.key)` block, add this case after the existing `'c'` case:
 ```ts
    case ' ':
      e.preventDefault()
      document.dispatchEvent(new CustomEvent('voice:ptt-toggle'))
      break
 ```
 #### Template changes
 - [ ] **Step 3: Mount `VoiceOverlay` in the authenticated template**
 Find `<ToastNotification />` near the bottom of the authenticated template block and add `<VoiceOverlay />` directly above it:
 ```html
    <VoiceOverlay />
    <ToastNotification />
 ```
 - [ ] **Step 4: Update Space bar description in shortcuts panel**
 Find:
 ```html
                <span class="shortcut-desc">Hold to speak (voice, when enabled)</span>
 ```
 Replace with:
 ```html
                <span class="shortcut-desc">Tap to speak (voice, when enabled)</span>
 ```
 - [ ] **Step 5: Verify TypeScript compiles**
 ```bash
 npx tsc --noEmit
 ```
 Expected: no errors.
 - [ ] **Step 6: Verify full build succeeds**
 ```bash
 npm run build
 ```
 Expected: build completes with no errors.
 - [ ] **Step 7: Manual smoke test**
 1. Start the dev server: `npm run dev`
 2. Log in — confirm the floating mic button appears in the bottom-right corner
 3. Ensure voice is enabled in Settings → Voice
 4. Click the mic button — confirm it turns red with animated amplitude bars
 5. Speak — bars should animate with your voice
 6. Stop speaking — after ~1.5 s of silence, the button should switch to purple (transcribing), then green (speaking) as it plays back the response
 7. Click the mic while recording — confirm it stops immediately
 8. Press Space (not in an input field) — confirm it starts/stops recording
 9. Press Space in the chat input — confirm it does NOT trigger voice
 - [ ] **Step 8: Commit**
 ```bash
 git add frontend/src/App.vue
 git commit -m "feat: mount VoiceOverlay and wire Space bar shortcut in App.vue"
 ```
@@ -0,0 +1,746 @@
 # Knowledge View Task Consolidation — 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:** Consolidate tasks into the Knowledge view as a fifth card type, deprecate `/notes` and `/tasks` list routes, and simplify navigation down to a single Knowledge hub.
 **Architecture:** The backend knowledge service (`services/knowledge.py`) stops excluding tasks from queries and adds `type=task` filtering via the `is_task` property (`Note.status IS NOT NULL`). The knowledge route validation gains `"task"` as a valid type. The frontend KnowledgeView gains task card rendering with status/priority/due-date badges. Router redirects replace the deleted list views.
 **Tech Stack:** Python/Quart backend (SQLAlchemy), Vue 3 + TypeScript frontend, Pinia stores, Vue Router.
 ---
 ## File Map
 | Action | Path |
 |--------|------|
 | Modify | `src/fabledassistant/services/knowledge.py` |
 | Modify | `src/fabledassistant/routes/knowledge.py` |
 | Modify | `frontend/src/views/KnowledgeView.vue` |
 | Modify | `frontend/src/router/index.ts` |
 | Modify | `frontend/src/components/AppHeader.vue` |
 | Modify | `frontend/src/App.vue` |
 | Delete | `frontend/src/views/NotesListView.vue` |
 | Delete | `frontend/src/views/TasksListView.vue` |
 ---
 ### Task 1: Backend — Include tasks in knowledge queries
 **Files:**
 - Modify: `src/fabledassistant/services/knowledge.py`
 - Modify: `src/fabledassistant/routes/knowledge.py`
 **Context:** The knowledge service currently excludes tasks by filtering `Note.status.is_(None)`. Every query function (`query_knowledge`, `query_knowledge_ids`, `_semantic_knowledge_search`, `get_knowledge_tags`, `get_knowledge_counts`) has this exclusion. Adding task support means: (1) removing the task exclusion from the "all types" queries, (2) adding `type=task` as a filter option that maps to `Note.status.isnot(None)`, (3) enriching `_note_to_item` with task-specific fields, (4) updating counts to include tasks.
 - [ ] **Step 1: Add `"task"` to `_VALID_TYPES` in the route file**
 In `src/fabledassistant/routes/knowledge.py`, change:
 ```python
 _VALID_TYPES = {"note", "person", "place", "list"}
 ```
 to:
 ```python
 _VALID_TYPES = {"note", "person", "place", "list", "task"}
 ```
 - [ ] **Step 2: Update `_note_to_item` to include task fields**
 In `src/fabledassistant/services/knowledge.py`, the `_note_to_item` function builds the item dict. After the existing `elif note.entity_type == "list":` block (which ends around line 48), add a task branch. Find:
 ```python
    elif note.entity_type == "list":
        # Parse markdown task list syntax into structured items
        body = note.body or ""
        list_items = []
        for line in body.split("\n"):
            stripped = line.strip()
            if stripped.startswith("- [ ] ") or stripped.startswith("- [x] ") or stripped.startswith("- [X] "):
                checked_item = not stripped.startswith("- [ ] ")
                list_items.append({"text": stripped[6:], "checked": checked_item})
        item["list_items"] = list_items
        item["item_count"] = len(list_items)
        item["checked_count"] = sum(1 for i in list_items if i["checked"])
        item["body"] = body
    return item
 ```
 Replace with:
 ```python
    elif note.entity_type == "list":
        # Parse markdown task list syntax into structured items
        body = note.body or ""
        list_items = []
        for line in body.split("\n"):
            stripped = line.strip()
            if stripped.startswith("- [ ] ") or stripped.startswith("- [x] ") or stripped.startswith("- [X] "):
                checked_item = not stripped.startswith("- [ ] ")
                list_items.append({"text": stripped[6:], "checked": checked_item})
        item["list_items"] = list_items
        item["item_count"] = len(list_items)
        item["checked_count"] = sum(1 for i in list_items if i["checked"])
        item["body"] = body
    # Task fields — included for all items but only meaningful when is_task
    if note.is_task:
        item["note_type"] = "task"
        item["status"] = note.status
        item["priority"] = note.priority
        item["due_date"] = note.due_date.isoformat() if note.due_date else None
    return item
 ```
 This overrides `note_type` to `"task"` for task items (since `entity_type` returns the `note_type` column which is `"note"` for tasks) and adds status/priority/due_date fields.
 - [ ] **Step 3: Update `query_knowledge` to include tasks**
 In the `query_knowledge` function, the "all types" filter currently excludes tasks. Change the base query and the `else` branch.
 Find:
 ```python
        base = (
            select(Note)
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))  # exclude tasks
        )
        if note_type:
            base = base.where(Note.note_type == note_type)
        else:
            # Exclude tasks — already done above; also exclude any legacy nulls
            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
 ```
 Replace with:
 ```python
        base = select(Note).where(Note.user_id == user_id)
        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))
        else:
            # All types including tasks
            pass
 ```
 - [ ] **Step 4: Update `_semantic_knowledge_search` to include tasks**
 Find:
 ```python
        candidates = await semantic_search_notes(
            user_id=user_id,
            query=q,
            limit=min(200, limit * 8),
            threshold=0.3,
            is_task=False,
        )
 ```
 Replace with:
 ```python
        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),
            threshold=0.3,
            is_task=is_task_filter,
        )
 ```
 Also update the type matching in the filter loop — find:
 ```python
    for _score, note in candidates:
        if note_type and note.entity_type != note_type:
            continue
 ```
 Replace with:
 ```python
    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
 ```
 - [ ] **Step 5: Update `query_knowledge_ids` to include tasks**
 Find:
 ```python
        base = (
            select(Note.id)
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))
        )
        if note_type:
            base = base.where(Note.note_type == note_type)
        else:
            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
 ```
 Replace with:
 ```python
        base = select(Note.id).where(Note.user_id == user_id)
        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))
        else:
            pass
 ```
 - [ ] **Step 6: Update `get_knowledge_tags` to include task tags**
 Find:
 ```python
        base = (
            select(func.unnest(Note.tags).label("tag"))
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))
        )
        if note_type:
            base = base.where(Note.note_type == note_type)
        else:
            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
 ```
 Replace with:
 ```python
        base = (
            select(func.unnest(Note.tags).label("tag"))
            .where(Note.user_id == user_id)
        )
        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))
        else:
            pass
 ```
 - [ ] **Step 7: Update `get_knowledge_counts` to include tasks**
 Find:
 ```python
    async with async_session() as session:
        stmt = (
            select(Note.note_type, func.count(Note.id))
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))
            .where(Note.note_type.in_(["note", "person", "place", "list"]))
            .group_by(Note.note_type)
        )
        if tags:
            for tag in tags:
                stmt = stmt.where(Note.tags.contains([tag]))
        rows = list((await session.execute(stmt)).all())
    counts = {row[0]: row[1] for row in rows}
    # Ensure all types present even if zero
    for t in ("note", "person", "place", "list"):
        counts.setdefault(t, 0)
    counts["total"] = sum(counts[t] for t in ("note", "person", "place", "list"))
    return counts
 ```
 Replace with:
 ```python
    async with async_session() as session:
        # Count non-task types
        stmt = (
            select(Note.note_type, func.count(Note.id))
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))
            .where(Note.note_type.in_(["note", "person", "place", "list"]))
            .group_by(Note.note_type)
        )
        if tags:
            for tag in tags:
                stmt = stmt.where(Note.tags.contains([tag]))
        rows = list((await session.execute(stmt)).all())
        counts = {row[0]: row[1] for row in rows}
        # Count tasks separately (is_task = status IS NOT NULL)
        task_stmt = (
            select(func.count(Note.id))
            .where(Note.user_id == user_id)
            .where(Note.status.isnot(None))
        )
        if tags:
            for tag in tags:
                task_stmt = task_stmt.where(Note.tags.contains([tag]))
        task_count: int = (await session.execute(task_stmt)).scalar_one()
        counts["task"] = task_count
    for t in ("note", "person", "place", "list", "task"):
        counts.setdefault(t, 0)
    counts["total"] = sum(counts[t] for t in ("note", "person", "place", "list", "task"))
    return counts
 ```
 - [ ] **Step 8: Verify backend changes**
 ```bash
 cd /path/to/fabledassistant
 make typecheck
 make test
 ```
 Expected: no errors.
 - [ ] **Step 9: Commit**
 ```bash
 git add src/fabledassistant/services/knowledge.py src/fabledassistant/routes/knowledge.py
 git commit -m "feat(knowledge): include tasks in knowledge queries and counts"
 ```
 ---
 ### Task 2: Frontend — Task card rendering in KnowledgeView
 **Files:**
 - Modify: `frontend/src/views/KnowledgeView.vue`
 **Context:** `KnowledgeView.vue` has a `KnowledgeItem` interface and renders cards in a grid. Each card type has type-specific content (person shows relationship/email, list shows checkboxes, etc.). Task cards need status, priority, and due date display. The `activeType` ref controls filtering; it needs `"task"` as a valid value. The type filter sidebar needs a "Tasks" button. The new-note button interaction changes from split-button to toggle.
 - [ ] **Step 1: Add `"task"` to the KnowledgeItem interface and filter type**
 In the `<script setup>` section, find the `KnowledgeItem` interface and add task fields:
 ```ts
 interface KnowledgeItem {
  id: number;
  note_type: "note" | "person" | "place" | "list";
  // ... existing fields
 ```
 Change to:
 ```ts
 interface KnowledgeItem {
  id: number;
  note_type: "note" | "person" | "place" | "list" | "task";
  // ... existing fields
 ```
 Also add the task-specific fields at the end of the interface (before the closing `}`):
 ```ts
  // Task-specific
  status?: string;
  priority?: string;
  due_date?: string;
 ```
 Update the `activeType` ref type:
 ```ts
 const activeType = ref<"" | "note" | "person" | "place" | "list">(""); 
 ```
 Change to:
 ```ts
 const activeType = ref<"" | "note" | "person" | "place" | "list" | "task">("");
 ```
 - [ ] **Step 2: Add "Tasks" to the type filter sidebar**
 Find the type filter `v-for` in the template:
 ```html
          <button
            v-for="[val, label, key] in ([['note','Notes','note'],['person','People','person'],['place','Places','place'],['list','Lists','list']] as [string,string,string][])"
 ```
 Replace with:
 ```html
          <button
            v-for="[val, label, key] in ([['note','Notes','note'],['task','Tasks','task'],['person','People','person'],['place','Places','place'],['list','Lists','list']] as [string,string,string][])"
 ```
 Update the type cast on the click handler. Find:
 ```html
            @click="activeType = (val as '' | 'note' | 'person' | 'place' | 'list')"
 ```
 Replace with:
 ```html
            @click="activeType = (val as '' | 'note' | 'person' | 'place' | 'list' | 'task')"
 ```
 - [ ] **Step 3: Add task card content in the template**
 In the card grid, find the note snippet section:
 ```html
              <!-- Note snippet -->
              <p v-else-if="item.snippet" class="k-card-snippet">{{ item.snippet }}</p>
 ```
 Add a task-specific section above it:
 ```html
              <!-- Task specifics -->
              <div v-else-if="item.note_type === 'task'" class="k-card-task">
                <div class="task-badges">
                  <span class="status-badge" :class="`status--${item.status}`">
                    {{ item.status === 'in_progress' ? 'in progress' : item.status }}
                  </span>
                  <span
                    v-if="item.priority && item.priority !== 'none'"
                    class="priority-badge"
                    :class="`priority--${item.priority}`"
                  >{{ item.priority }}</span>
                </div>
                <span
                  v-if="item.due_date"
                  class="task-due"
                  :class="{ 'task-overdue': isOverdue(item) }"
                >{{ formatDate(item.due_date) }}</span>
                <p v-if="item.snippet" class="k-card-snippet">{{ item.snippet }}</p>
              </div>
              <!-- Note snippet -->
              <p v-else-if="item.snippet" class="k-card-snippet">{{ item.snippet }}</p>
 ```
 - [ ] **Step 4: Add `isOverdue` helper and update `openItem` for tasks**
 In the `<script setup>`, add after the `formatDate` function:
 ```ts
 function isOverdue(item: KnowledgeItem): boolean {
  if (!item.due_date || item.status === 'done' || item.status === 'cancelled') return false;
  return new Date(item.due_date) < new Date(new Date().toDateString());
 }
 ```
 Update `openItem` to route tasks to their editor:
 ```ts
 function openItem(item: KnowledgeItem) {
  if (item.note_type === 'task') {
    router.push(`/tasks/${item.id}`);
  } else {
    router.push(`/notes/${item.id}`);
  }
 }
 ```
 - [ ] **Step 5: Update the "New note" button to toggle interaction**
 Find the current new-note button markup:
 ```html
        <div class="new-note-wrap">
          <button class="btn-new-note" @click="createNew('note')">+ New note</button>
          <button class="btn-new-chevron" @click="newNoteMenuOpen = !newNoteMenuOpen" :class="{ open: newNoteMenuOpen }" title="Create specific type">▾</button>
          <div v-if="newNoteMenuOpen" class="new-note-menu">
            <button @click="createNew('note')">Note</button>
            <button @click="createNew('person')">Person</button>
            <button @click="createNew('place')">Place</button>
            <button @click="createNew('list')">List</button>
          </div>
        </div>
 ```
 Replace with:
 ```html
        <div class="new-note-wrap">
          <button class="btn-new-note" @click="newNoteMenuOpen ? createNew('note') : (newNoteMenuOpen = true)">+ New note</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>
          </div>
        </div>
 ```
 Add a click-outside handler. In the `<script setup>`, add after the `createNew` function:
 ```ts
 function onClickOutsideNewNote(e: MouseEvent) {
  const wrap = document.querySelector('.new-note-wrap');
  if (wrap && !wrap.contains(e.target as Node)) {
    newNoteMenuOpen.value = false;
  }
 }
 ```
 In `onMounted`, add:
 ```ts
 document.addEventListener('click', onClickOutsideNewNote);
 ```
 In `onUnmounted`, add:
 ```ts
 document.removeEventListener('click', onClickOutsideNewNote);
 ```
 - [ ] **Step 6: Add task card CSS**
 Append to the `<style scoped>` block:
 ```css
 /* ── Task card ──────────────────────────────────────────── */
 .k-card--task { border-left: 3px solid #a78bfa; }
 .k-card-task {
  display: flex;
  flex-direction: column;
  gap: 6px;
 }
 .task-badges {
  display: flex;
  gap: 5px;
  flex-wrap: wrap;
 }
 .status-badge {
  font-size: 0.7rem;
  padding: 1px 7px;
  border-radius: 8px;
  font-weight: 600;
 }
 .status--todo { background: var(--color-status-todo-bg); color: var(--color-status-todo); }
 .status--in_progress { background: var(--color-status-in-progress-bg); color: var(--color-status-in-progress); }
 .status--done { background: var(--color-status-done-bg); color: var(--color-status-done); }
 .status--cancelled { background: var(--color-status-todo-bg); color: var(--color-status-todo); text-decoration: line-through; }
 .priority-badge {
  font-size: 0.7rem;
  padding: 1px 7px;
  border-radius: 8px;
  font-weight: 600;
 }
 .priority--low { background: var(--color-priority-low-bg); color: var(--color-priority-low); }
 .priority--normal { background: var(--color-priority-medium-bg); color: var(--color-priority-medium); }
 .priority--high { background: var(--color-priority-high-bg); color: var(--color-priority-high); }
 .task-due {
  font-size: 0.78rem;
  color: var(--color-text-muted);
 }
 .task-overdue {
  color: var(--color-overdue);
  font-weight: 500;
 }
 ```
 Also add the task type badge color. Find:
 ```css
 .badge--list   { background: rgba(56,189,248,0.15); color: #7dd3fc; }
 ```
 Add after it:
 ```css
 .badge--task   { background: rgba(167,139,250,0.15); color: #a78bfa; }
 ```
 - [ ] **Step 7: Remove the chevron button CSS**
 Find and delete:
 ```css
 .btn-new-chevron {
  padding: 7px 9px;
  border-radius: 0 8px 8px 0;
  border: 1px solid rgba(99, 102, 241, 0.4);
  background: rgba(99, 102, 241, 0.12);
  color: var(--color-primary, #818cf8);
  cursor: pointer;
  font-size: 0.78rem;
  line-height: 1;
  transition: background 0.15s, transform 0.15s;
 }
 .btn-new-chevron:hover { background: rgba(99, 102, 241, 0.2); }
 .btn-new-chevron.open { transform: scaleY(-1); }
 ```
 Update `.btn-new-note` to have full border-radius now that the chevron is gone:
 ```css
 .btn-new-note {
  flex: 1;
  padding: 7px 10px;
  border-radius: 8px;
  border: 1px solid rgba(99, 102, 241, 0.4);
  background: rgba(99, 102, 241, 0.12);
  color: var(--color-primary, #818cf8);
  cursor: pointer;
  font-size: 0.85rem;
  font-weight: 500;
  text-align: left;
  transition: background 0.15s;
 }
 ```
 - [ ] **Step 8: Verify TypeScript compiles**
 ```bash
 cd /path/to/fabledassistant/frontend
 npx tsc --noEmit
 ```
 Expected: no new errors (pre-existing TipTap errors are fine).
 - [ ] **Step 9: Commit**
 ```bash
 git add frontend/src/views/KnowledgeView.vue
 git commit -m "feat(knowledge): add task cards with status/priority/due-date display"
 ```
 ---
 ### Task 3: Route redirects, navigation cleanup, dead code removal
 **Files:**
 - Modify: `frontend/src/router/index.ts`
 - Modify: `frontend/src/components/AppHeader.vue`
 - Modify: `frontend/src/App.vue`
 - Delete: `frontend/src/views/NotesListView.vue`
 - Delete: `frontend/src/views/TasksListView.vue`
 **Context:** The router currently has `/notes` and `/tasks` pointing to list view components. These become redirects to `/`. The AppHeader has "Tasks" in both desktop and mobile nav. The `g+t` keyboard shortcut navigates to `/tasks` which should change to `/`. The stores (`notes.ts`, `tasks.ts`) are used by other views so they stay.
 - [ ] **Step 1: Replace list view routes with redirects**
 In `frontend/src/router/index.ts`, find:
 ```ts
    {
      path: "/notes",
      name: "notes",
      component: () => import("@/views/NotesListView.vue"),
    },
 ```
 Replace with:
 ```ts
    {
      path: "/notes",
      redirect: "/",
    },
 ```
 Find:
 ```ts
    {
      path: "/tasks",
      name: "tasks",
      component: () => import("@/views/TasksListView.vue"),
    },
 ```
 Replace with:
 ```ts
    {
      path: "/tasks",
      redirect: "/",
    },
 ```
 - [ ] **Step 2: Remove "Tasks" from AppHeader navigation**
 In `frontend/src/components/AppHeader.vue`, find in the desktop nav-center:
 ```html
        <router-link to="/tasks" class="nav-link">Tasks</router-link>
 ```
 Delete this line.
 Find in the mobile dropdown menu:
 ```html
      <router-link to="/tasks" class="nav-link">Tasks</router-link>
 ```
 Delete this line.
 - [ ] **Step 3: Update `g+t` keyboard shortcut in App.vue**
 In `frontend/src/App.vue`, find in the `onGlobalKeydown` function, inside the `if (pendingPrefix === "g")` block:
 ```ts
      case "t": router.push("/tasks"); break;
 ```
 Replace with:
 ```ts
      case "t": router.push("/"); break;
 ```
 - [ ] **Step 4: Update shortcuts overlay text**
 In `frontend/src/App.vue`, find in the shortcuts overlay template:
 ```html
                <kbd class="shortcut-key">t</kbd>
                <span class="shortcut-desc">Tasks</span>
 ```
 Replace the description:
 ```html
                <kbd class="shortcut-key">t</kbd>
                <span class="shortcut-desc">Knowledge (tasks)</span>
 ```
 - [ ] **Step 5: Delete the deprecated list view files**
 ```bash
 rm frontend/src/views/NotesListView.vue
 rm frontend/src/views/TasksListView.vue
 ```
 - [ ] **Step 6: Verify build**
 ```bash
 cd /path/to/fabledassistant/frontend
 npx tsc --noEmit
 ```
 Expected: no new errors. The deleted files were only imported via lazy `() => import(...)` in the router, which we already replaced with redirects.
 - [ ] **Step 7: Commit**
 ```bash
 git add -A frontend/src/views/NotesListView.vue frontend/src/views/TasksListView.vue \
  frontend/src/router/index.ts frontend/src/components/AppHeader.vue frontend/src/App.vue
 git commit -m "feat: deprecate /notes and /tasks routes; redirect to Knowledge view"
 ```
@@ -0,0 +1,785 @@
 # Modern Fable Visual Identity — 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 indigo dark-mode palette with a distinctive "Modern Fable" visual identity — deep violet + muted gold, signature card types, pill nav, Fraunces-as-narrator typography, and living micro-details.
 **Architecture:** Pure frontend changes across theme CSS, AppHeader, AppLogo, KnowledgeView, ChatPanel, BriefingView, and CalendarView. No backend changes. Each task is independently deployable — palette first, then cards, then nav, then typography, then details.
 **Tech Stack:** Vue 3 SFC (scoped CSS), CSS custom properties, Fraunces font (already loaded).
 ---
 ## File Map
 | Action | Path |
 |--------|------|
 | Modify | `frontend/src/assets/theme.css` |
 | Modify | `frontend/src/components/AppLogo.vue` |
 | Modify | `frontend/src/components/AppHeader.vue` |
 | Modify | `frontend/src/views/KnowledgeView.vue` |
 | Modify | `frontend/src/components/ChatPanel.vue` |
 | Modify | `frontend/src/views/BriefingView.vue` |
 | Modify | `frontend/src/views/CalendarView.vue` |
 | Modify | `frontend/src/App.vue` |
 ---
 ### Task 1: Color palette update + logo + scrollbar
 **Files:**
 - Modify: `frontend/src/assets/theme.css`
 - Modify: `frontend/src/components/AppLogo.vue`
 - [ ] **Step 1: Update the dark theme palette in theme.css**
 In `frontend/src/assets/theme.css`, find the `[data-theme="dark"]` block and replace these values:
 ```css
 [data-theme="dark"] {
  --color-bg: #0f0f14;
  --color-bg-secondary: #16161f;
  --color-bg-card: #1a1a24;
  --color-surface: #16161f;
  --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-primary: #a78bfa;
  --color-danger: #f44336;
  --color-tag-bg: #2a2a45;
  --color-tag-text: #c4b5fd;
  --color-shadow: rgba(0, 0, 0, 0.4);
  --color-toast-success: #4caf50;
  --color-toast-error: #f44336;
  --color-status-todo: #9aa0a6;
  --color-status-todo-bg: #2a2a35;
  --color-status-in-progress: #a78bfa;
  --color-status-in-progress-bg: #2a2a45;
  --color-status-done: #4caf50;
  --color-status-done-bg: #1b3a20;
  --color-priority-low: #80cbc4;
  --color-priority-low-bg: #1a3a38;
  --color-priority-medium: #fdd835;
  --color-priority-medium-bg: #3a3520;
  --color-priority-high: #f44336;
  --color-priority-high-bg: #3a1a1a;
  --color-wikilink: #c4b5fd;
  --color-wikilink-bg: #2a1a45;
  --color-overdue: #f44336;
  --color-code-bg: #12121a;
  --color-code-inline-bg: #1a1a2a;
  --color-table-stripe: #14141e;
  --color-success: #4ade80;
  --color-warning: #facc15;
  --color-input-bar-bg: #1a1a24;
  --color-input-bar-text: #e4e4f0;
  --color-input-bar-placeholder: rgba(228, 228, 240, 0.35);
  --color-overlay: rgba(0, 0, 0, 0.65);
  --color-bubble-user-bg: rgba(255, 255, 255, 0.04);
  --color-bubble-user-border: rgba(255, 255, 255, 0.10);
  --color-bubble-user-text: #b0b0c8;
  --color-bubble-asst-shadow: 0 4px 28px rgba(124, 58, 237, 0.14), 0 2px 8px rgba(0, 0, 0, 0.4);
  --color-accent-warm: #d4a017;
  --color-accent-warm-light: #e8c45a;
  --color-primary-solid: #7c3aed;
  --color-primary-deep: #5b21b6;
 }
 ```
 Note: `--color-accent-warm`, `--color-accent-warm-light`, `--color-primary-solid`, and `--color-primary-deep` are new variables.
 - [ ] **Step 2: Update the light theme palette**
 In the `:root` block, update these values:
 ```css
 :root {
  --color-bg: #f5f5fb;
  --color-bg-secondary: #ededf5;
  --color-bg-card: #ffffff;
  --color-surface: #f0f0f8;
  --color-text: #1a1a1a;
  --color-text-secondary: #666666;
  --color-text-muted: #999999;
  --color-border: #dddde8;
  --color-input-border: #c8c8d8;
  --color-primary: #7c3aed;
  --color-danger: #d93025;
  --color-tag-bg: #ede5ff;
  --color-tag-text: #6d28d9;
  --color-shadow: rgba(0, 0, 0, 0.08);
  --color-toast-success: #34a853;
  --color-toast-error: #d93025;
  --color-status-todo: #5f6368;
  --color-status-todo-bg: #e8eaed;
  --color-status-in-progress: #7c3aed;
  --color-status-in-progress-bg: #ede5ff;
  --color-status-done: #34a853;
  --color-status-done-bg: #e6f4ea;
  --color-priority-low: #5f9ea0;
  --color-priority-low-bg: #e0f2f1;
  --color-priority-medium: #f9a825;
  --color-priority-medium-bg: #fff8e1;
  --color-priority-high: #d93025;
  --color-priority-high-bg: #fce8e6;
  --color-wikilink: #7b1fa2;
  --color-wikilink-bg: #f3e5f5;
  --color-overdue: #d93025;
  --color-code-bg: #f0f0f8;
  --color-code-inline-bg: #eaeaf4;
  --color-table-stripe: #f4f4fb;
  --color-success: #22c55e;
  --color-warning: #eab308;
  --color-input-bar-bg: #eaeaf3;
  --color-input-bar-text: #1a1a1a;
  --color-input-bar-placeholder: rgba(0, 0, 0, 0.4);
  --color-overlay: rgba(0, 0, 0, 0.45);
  --color-bubble-user-bg: rgba(0, 0, 0, 0.04);
  --color-bubble-user-border: rgba(0, 0, 0, 0.10);
  --color-bubble-user-text: #3a3a4a;
  --color-bubble-asst-shadow: 0 2px 16px rgba(124, 58, 237, 0.10), 0 1px 4px rgba(0, 0, 0, 0.06);
  --radius-sm: 6px;
  --radius-md: 12px;
  --radius-lg: 18px;
  --radius-pill: 9999px;
  --focus-ring: 0 0 0 2px rgba(124, 58, 237, 0.4);
  /* Layout */
  --page-max-width: 1200px;
  --page-padding-x: 1rem;
  --sidebar-width: 260px;
  /* New brand variables */
  --color-accent-warm: #b8860b;
  --color-accent-warm-light: #d4a017;
  --color-primary-solid: #7c3aed;
  --color-primary-deep: #5b21b6;
 }
 ```
 - [ ] **Step 3: Update scrollbar color**
 Find:
 ```css
 ::-webkit-scrollbar-thumb {
  background: rgba(99, 102, 241, 0.25);
 }
 ::-webkit-scrollbar-thumb:hover {
  background: rgba(99, 102, 241, 0.45);
 }
 ```
 Replace with:
 ```css
 ::-webkit-scrollbar-thumb {
  background: rgba(124, 58, 237, 0.25);
 }
 ::-webkit-scrollbar-thumb:hover {
  background: rgba(124, 58, 237, 0.45);
 }
 ```
 - [ ] **Step 4: Update focus ring**
 Find:
 ```css
  --focus-ring: 0 0 0 2px color-mix(in srgb, var(--color-primary) 40%, transparent);
 ```
 Replace with:
 ```css
  --focus-ring: 0 0 0 2px rgba(124, 58, 237, 0.4);
 ```
 - [ ] **Step 5: Update AppLogo gradient**
 In `frontend/src/components/AppLogo.vue`, the logo uses `var(--color-primary)` which will automatically pick up the new violet value. No code change needed — the CSS variable update handles it.
 However, add a gradient `<defs>` for the book fill to use the deep gradient instead of a flat color. Find the `<style scoped>` block:
 ```css
 .logo-book {
  fill: var(--color-primary);
  stroke: color-mix(in srgb, var(--color-primary) 70%, transparent);
 }
 ```
 Replace with:
 ```css
 .logo-book {
  fill: url(#logo-gradient);
  stroke: color-mix(in srgb, var(--color-primary) 70%, transparent);
 }
 ```
 And add a gradient definition inside the `<svg>` element, before the `<!-- Book body -->` comment:
 ```html
    <defs>
      <linearGradient id="logo-gradient" x1="0" y1="0" x2="1" y2="1">
        <stop offset="0%" stop-color="var(--color-primary-solid)" />
        <stop offset="100%" stop-color="var(--color-primary-deep)" />
      </linearGradient>
    </defs>
 ```
 - [ ] **Step 6: Verify TypeScript compiles**
 ```bash
 cd frontend && npx tsc --noEmit
 ```
 - [ ] **Step 7: Commit**
 ```bash
 git add frontend/src/assets/theme.css frontend/src/components/AppLogo.vue
 git commit -m "feat(theme): shift palette from indigo to deep violet + muted gold"
 ```
 ---
 ### Task 2: Signature header — pill nav + brand shortening + status pulse
 **Files:**
 - Modify: `frontend/src/components/AppHeader.vue`
 - [ ] **Step 1: Update brand text in header**
 Find:
 ```html
        Fabled Assistant
 ```
 Replace with:
 ```html
        <span class="brand-text">Fabled</span>
 ```
 - [ ] **Step 2: Wrap nav-center links in a pill container**
 Find the `nav-center` div:
 ```html
      <div class="nav-center">
        <router-link to="/" class="nav-link" :class="{ 'router-link-active': isKnowledgeActive }">Knowledge</router-link>
        <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 to="/projects" class="nav-link">Projects</router-link>
      </div>
 ```
 Replace with:
 ```html
      <div class="nav-center">
        <div class="nav-pill-bar">
          <router-link to="/" class="nav-link" :class="{ 'router-link-active': isKnowledgeActive }">Knowledge</router-link>
          <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 to="/projects" class="nav-link">Projects</router-link>
        </div>
      </div>
 ```
 - [ ] **Step 3: Replace header and nav CSS**
 Replace the entire `<style scoped>` from `.app-header` through `.nav-link.router-link-active` with:
 ```css
 .app-header {
  background: linear-gradient(180deg, var(--color-surface), var(--color-bg));
  border-bottom: 1px solid rgba(124, 58, 237, 0.08);
  position: relative;
 }
 .nav {
  padding: 0.6rem 1.5rem;
  display: flex;
  align-items: center;
  justify-content: space-between;
  position: relative;
 }
 /* Left — brand */
 .nav-brand {
  display: flex;
  align-items: center;
  gap: 0.45rem;
  text-decoration: none;
  flex-shrink: 0;
 }
 .brand-text {
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  font-optical-sizing: auto;
  font-weight: 600;
  font-size: 1rem;
  letter-spacing: -0.01em;
  color: #c4b0f0;
 }
 /* Center — pill bar */
 .nav-center {
  position: absolute;
  left: 50%;
  transform: translateX(-50%);
  display: flex;
  align-items: center;
 }
 .nav-pill-bar {
  display: flex;
  align-items: center;
  gap: 2px;
  background: rgba(124, 58, 237, 0.06);
  border-radius: 10px;
  padding: 3px;
 }
 /* Right */
 .nav-right {
  display: flex;
  align-items: center;
  gap: 0.25rem;
  flex-shrink: 0;
 }
 .nav-link {
  color: var(--color-text-muted);
  text-decoration: none;
  font-size: 0.82rem;
  padding: 0.3rem 0.75rem;
  border-radius: 8px;
  transition: background 0.15s, color 0.15s;
 }
 .nav-link:hover {
  color: var(--color-text-secondary);
  background: rgba(124, 58, 237, 0.08);
 }
 .nav-link.router-link-active {
  color: #c4b5fd;
  font-weight: 600;
  background: rgba(124, 58, 237, 0.2);
  box-shadow: 0 0 12px rgba(124, 58, 237, 0.2);
 }
 ```
 - [ ] **Step 4: Add status dot pulse animation for loaded state**
 Find:
 ```css
 .status-green .status-dot  { background: var(--color-success, #2ecc71); }
 ```
 Replace with:
 ```css
 .status-green .status-dot  { background: var(--color-success, #2ecc71); animation: status-pulse 2.5s ease-in-out infinite; }
 ```
 Find:
 ```css
@keyframes pulse-dot {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.3; }
 }
 ```
 Add after it:
 ```css
@keyframes status-pulse {
  0%, 100% { box-shadow: 0 0 4px rgba(74, 222, 128, 0.4); }
  50% { box-shadow: 0 0 10px rgba(74, 222, 128, 0.6); }
 }
 ```
 - [ ] **Step 5: Update mobile menu active styling**
 Find:
 ```css
  .mobile-menu .nav-link {
    padding: 0.5rem 0.75rem;
    min-height: 44px;
    display: flex;
    align-items: center;
  }
 ```
 Replace with:
 ```css
  .mobile-menu .nav-link {
    padding: 0.5rem 0.75rem;
    min-height: 44px;
    display: flex;
    align-items: center;
    border-radius: 8px;
  }
  .mobile-menu .nav-link.router-link-active {
    background: rgba(124, 58, 237, 0.15);
    box-shadow: none;
  }
 ```
 - [ ] **Step 6: Verify TypeScript compiles**
 ```bash
 cd frontend && npx tsc --noEmit
 ```
 - [ ] **Step 7: Commit**
 ```bash
 git add frontend/src/components/AppHeader.vue
 git commit -m "feat(header): pill nav bar, brand shortening, status pulse, header gradient"
 ```
 ---
 ### Task 3: Card type DNA — gradient bars, corner accents, hover bloom
 **Files:**
 - Modify: `frontend/src/views/KnowledgeView.vue`
 **Context:** The cards currently have a left accent strip per type. The new design replaces this with top gradient bars (notes, tasks, lists) and corner accents (person, place), plus a unified violet hover bloom.
 - [ ] **Step 1: Replace card accent strips with type-specific top bars and borders**
 Find in the `<style scoped>`:
 ```css
 /* Type accent strip */
 .k-card--person { border-left: 3px solid #10b981; }
 .k-card--place  { border-left: 3px solid #f59e0b; }
 .k-card--list   { border-left: 3px solid #38bdf8; }
 .k-card--note   { border-left: 3px solid #6366f1; }
 .k-card--task   { border-left: 3px solid #a78bfa; }
 ```
 Replace with:
 ```css
 /* 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); }
 /* Top gradient bars */
 .k-card--note::before,
 .k-card--task::before,
 .k-card--list::before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  height: 3px;
  border-radius: 14px 14px 0 0;
 }
 .k-card--note::before {
  right: 0;
  background: linear-gradient(90deg, #7c3aed, #a78bfa);
 }
 .k-card--task::before {
  width: 50%;
  background: linear-gradient(90deg, #d4a017, transparent);
 }
 .k-card--list::before {
  right: 0;
  background: linear-gradient(90deg, #38bdf8, #7dd3fc);
 }
 /* Corner accents for entity types */
 .k-card--person::after,
 .k-card--place::after {
  content: '';
  position: absolute;
  top: 0;
  right: 0;
  width: 60px;
  height: 60px;
  border-radius: 0 14px 0 60px;
  pointer-events: none;
 }
 .k-card--person::after { background: rgba(16, 185, 129, 0.06); }
 .k-card--place::after  { background: rgba(245, 158, 11, 0.06); }
 ```
 - [ ] **Step 2: Update card hover to violet bloom**
 Find:
 ```css
 .k-card:hover {
  border-color: rgba(255,255,255,0.14);
  transform: translateY(-1px);
  box-shadow: 0 4px 16px rgba(0,0,0,0.2);
 }
 ```
 Replace with:
 ```css
 .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);
 }
 ```
 - [ ] **Step 3: Add sidebar section dividers**
 Find:
 ```css
 .filter-section { margin-bottom: 20px; }
 ```
 Replace with:
 ```css
 .filter-section { margin-bottom: 20px; }
 .filter-section + .filter-section::before {
  content: '· · ·';
  display: block;
  text-align: center;
  color: rgba(124, 58, 237, 0.3);
  font-size: 0.9rem;
  letter-spacing: 0.4em;
  padding: 4px 0 12px;
 }
 ```
 - [ ] **Step 4: Add scroll fade to card grid**
 Find:
 ```css
 .card-grid {
  flex: 1;
  overflow-y: auto;
  padding: 16px 20px;
 ```
 Replace with:
 ```css
 .card-grid {
  flex: 1;
  overflow-y: auto;
  padding: 16px 20px;
  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);
 ```
 - [ ] **Step 5: Update task card dates to use amber**
 Find in the task card CSS:
 ```css
 .task-due {
  font-size: 0.78rem;
  color: var(--color-text-muted);
 }
 ```
 Replace with:
 ```css
 .task-due {
  font-size: 0.78rem;
  color: var(--color-accent-warm);
 }
 ```
 - [ ] **Step 6: Add Fraunces view title and update sidebar labels**
 Find the filter panel label CSS:
 ```css
 .filter-label {
  font-size: 0.7rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
  color: var(--color-muted);
  margin-bottom: 6px;
  padding: 0 4px;
 }
 ```
 Replace with:
 ```css
 .filter-label {
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  font-size: 0.72rem;
  letter-spacing: 0.02em;
  color: var(--color-primary);
  margin-bottom: 6px;
  padding: 0 4px;
 }
 ```
 - [ ] **Step 7: Update empty state with Fraunces narrator voice**
 Find:
 ```html
        <div v-else-if="!loading && items.length === 0" class="knowledge-empty">
          <p>Nothing here yet.</p>
          <p v-if="activeType || activeTag || searchQuery" class="empty-hint">Try clearing the filters.</p>
          <p v-else class="empty-hint">Start by creating a note, saving a person or place, or making a list.</p>
        </div>
 ```
 Replace with:
 ```html
        <div v-else-if="!loading && items.length === 0" class="knowledge-empty">
          <p v-if="activeType || activeTag || searchQuery" class="empty-hint">No matches. Try clearing the filters.</p>
          <p v-else class="empty-narrator">Your story is unwritten. Create your first note to begin.</p>
        </div>
 ```
 Add CSS:
 ```css
 .empty-narrator {
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  font-size: 1rem;
  color: var(--color-accent-warm);
  opacity: 0.85;
 }
 ```
 - [ ] **Step 8: Update card date stamps to amber**
 Find:
 ```css
 .k-card-date { font-size: 0.72rem; color: var(--color-muted); white-space: nowrap; }
 ```
 Replace with:
 ```css
 .k-card-date { font-size: 0.72rem; color: var(--color-accent-warm); white-space: nowrap; opacity: 0.7; }
 ```
 - [ ] **Step 9: Verify TypeScript compiles**
 ```bash
 cd frontend && npx tsc --noEmit
 ```
 - [ ] **Step 10: Commit**
 ```bash
 git add frontend/src/views/KnowledgeView.vue
 git commit -m "feat(knowledge): card type DNA, violet hover bloom, amber timestamps, narrator empty states"
 ```
 ---
 ### Task 4: ChatPanel + BriefingView + CalendarView — empty states + glow buttons
 **Files:**
 - Modify: `frontend/src/components/ChatPanel.vue`
 - Modify: `frontend/src/views/BriefingView.vue`
 - Modify: `frontend/src/views/CalendarView.vue`
 - Modify: `frontend/src/App.vue`
 - [ ] **Step 1: Update ChatPanel empty state**
 In `frontend/src/components/ChatPanel.vue`, find:
 ```html
          >Send a message to start the conversation.</p>
 ```
 Replace with:
 ```html
          >Start a conversation.</p>
 ```
 Find the `.empty-msg` CSS:
 ```css
 .empty-msg {
 ```
 Add these properties (find the existing block and add to it):
 ```css
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  color: var(--color-accent-warm, #d4a017);
 ```
 - [ ] **Step 2: Add scroll fade to ChatPanel messages**
 Find the `.messages-container` CSS in ChatPanel.vue. Add:
 ```css
  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);
 ```
 - [ ] **Step 3: Update CalendarView empty state**
 In `frontend/src/views/CalendarView.vue`, find:
 ```html
      return ListView(
        children: const [
          SizedBox(height: 80),
          Center(child: Text('No events')),
        ],
      );
 ```
 Wait — that's the Flutter file. In the web CalendarView, there's no dedicated empty state text to update since it's a FullCalendar component. Skip this for the web CalendarView — it doesn't have a custom empty state.
 - [ ] **Step 4: Add glow to primary action buttons in App.vue global styles**
 In `frontend/src/App.vue`, find the `<style>` block (the global unscoped one). The `btn-send` styles are in `ChatInputBar.vue` which is scoped. Instead, add a global hover glow rule. Find the existing `.app-footer` style and add after it:
 No — the glow should be on the specific button components. The `btn-send` in `ChatInputBar.vue` already has a hover shadow. Let me update it there.
 In `frontend/src/components/ChatInputBar.vue`, find:
 ```css
 .btn-send:hover { box-shadow: 0 0 12px rgba(99, 102, 241, 0.5); }
 ```
 Replace with:
 ```css
 .btn-send:hover { box-shadow: 0 0 16px rgba(124, 58, 237, 0.35); }
 ```
 - [ ] **Step 5: Update KnowledgeView new-note button glow**
 In `frontend/src/views/KnowledgeView.vue`, find:
 ```css
 .btn-new-note:hover { background: rgba(99, 102, 241, 0.2); }
 ```
 Replace with:
 ```css
 .btn-new-note:hover { background: rgba(124, 58, 237, 0.2); box-shadow: 0 0 12px rgba(124, 58, 237, 0.25); }
 ```
 - [ ] **Step 6: Update any remaining hardcoded indigo references in KnowledgeView**
 Search for `99, 102, 241` in KnowledgeView.vue and replace with `124, 58, 237`. This covers all the rgba references in filter buttons, borders, today bar chips, etc.
 Use find-and-replace across the file: `99, 102, 241` → `124, 58, 237`
 - [ ] **Step 7: Update hardcoded indigo in BriefingView**
 Search for `99, 102, 241` in BriefingView.vue and replace with `124, 58, 237`.
 Search for `6366f1` in BriefingView.vue and replace with `7c3aed`.
 - [ ] **Step 8: Update hardcoded indigo in AppHeader**
 Search for `99, 102, 241` in AppHeader.vue and replace with `124, 58, 237` (for any remaining references not covered by Task 2).
 - [ ] **Step 9: Update hardcoded indigo in App.vue shortcuts overlay**
 Search for `99, 102, 241` in App.vue and replace with `124, 58, 237`.
 Search for `6366f1` in App.vue and replace with `7c3aed`.
 - [ ] **Step 10: Verify TypeScript compiles**
 ```bash
 cd frontend && npx tsc --noEmit
 ```
 - [ ] **Step 11: Commit**
 ```bash
 git add frontend/src/components/ChatPanel.vue frontend/src/components/ChatInputBar.vue \
  frontend/src/views/KnowledgeView.vue frontend/src/views/BriefingView.vue \
  frontend/src/components/AppHeader.vue frontend/src/App.vue
 git commit -m "feat: narrator empty states, scroll fades, glow buttons, violet color sweep"
 ```
@@ -0,0 +1,162 @@
 # Research Pipeline — Multi-Note Redesign
 > **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 single monolithic research note with a set of focused, topic-driven notes plus an index note that links them — making research output browsable, TTS-friendly, and well-organized.
 **Architecture:** Two new LLM calls (outline generation + N parallel section syntheses) replace the single large synthesis call. Public API unchanged — callers receive the index note. Fallback to single-note behavior on any outline failure.
 **Tech Stack:** Python/Quart backend, existing `research.py` service, asyncio.gather for parallelism.
 ---
 ## Problem
 The current pipeline synthesizes one note with a minimum of 2500 words and 6 sections. This creates:
 - Notes too large to read or listen to comfortably
 - No way to navigate directly to a specific sub-topic
 - TTS failures on long prose (8000-char route limit, unbounded sentence buffers)
 ---
 ## Pipeline Flow
 Public signature unchanged:
 ```python
 async def run_research_pipeline(
    topic: str,
    user_id: int,
    model: str,
    buf=None,
    project_id: int | None = None,
 ) -> Note:  # returns the index note
 ```
 Execution order:
 ```
 1. Generate sub-queries           (unchanged)
 2. Search + fetch sources         (unchanged)
 3. Generate topic outline         (NEW — one LLM call → 3–7 section dicts)
 4. Synthesize each section note   (NEW — parallelized via asyncio.gather)
 5. Create all section notes in DB (sequential, tagged ["research"], same project_id)
 6. Create index note              (NEW — links all sections)
 7. Return index note
 ```
 Status messages via `buf.append_event("status", ...)`:
 - `"Generating outline…"`
 - `"Writing: [Section Title]…"` (one per section, emitted before synthesis starts)
 - `"Saving [N] notes…"`
 No note content is streamed into chat. After the tool call resolves, the LLM writes a brief conversational summary citing the index note title and section count.
 ---
 ## Outline Generation
 New function: `_generate_outline(topic, sources, model) -> list[dict]`
 Sends all fetched sources to the model with a prompt requesting a JSON array:
 ```json
 [
  {"title": "Quantum Entanglement: Mechanisms", "focus": "How entanglement works at the physical level"},
  {"title": "Quantum Computing Hardware", "focus": "Ion traps, superconducting qubits, photonic approaches"}
 ]
 ```
 **Prompt requirements:**
 - Produce 3–7 sections covering distinct aspects of the topic
 - Titles must work as standalone note titles (no "Overview" or "Introduction" generics)
 - No overlap between sections
 - `focus` is one sentence describing what this section should specifically cover
 **Guardrails:**
 - Fewer than 3 sections parsed → fall back to single-note synthesis
 - JSON parse failure → fall back to single-note synthesis
 - More than 8 sections → truncate to 8
 **Model params:** `max_tokens=400, num_ctx=16384` (outline is short)
 ---
 ## Section Synthesis
 New function: `_synthesize_section(section_title, section_focus, sources, model) -> tuple[str, str]`
 Returns `(title, body_markdown)`.
 All sections receive all fetched sources. The `section_focus` field in the prompt directs the model to draw only what's relevant to that section's scope.
 **Prompt requirements:**
 - 300–600 words of substantive prose
 - Do NOT include a `# Title` heading (title is set separately)
 - End with a brief `## Sources` list of relevant URLs from the provided sources
 - Focus strictly on `section_focus` — ignore source material outside that scope
 **Model params:** `num_predict=2048, num_ctx=16384` (reduced from 8192 — sufficient for 600 words, prevents rambling)
 **Parallelism:** All section synthesis calls run via `asyncio.gather`. Wall-clock time stays close to a single synthesis call despite producing N notes.
 ---
 ## Note Creation and Index Note
 **Section notes:**
 - Tags: `["research"]`
 - `project_id`: same as passed to pipeline (or None)
 - Title: from outline `title` field
 - Created sequentially (avoids DB contention)
 **Index note:**
 - Tags: `["research", "research-index"]`
 - `project_id`: same as section notes
 - Title: `"Research: [topic]"`
 - Created last (after all section notes exist)
 **Index note body format:**
 ```markdown
 Research overview for **[topic]** — [YYYY-MM-DD]
 Generated from [N] web sources across [M] sections.
 ## Sections
 - **[Section 1 Title]** — [focus sentence]
 - **[Section 2 Title]** — [focus sentence]
 ...
 *Search for any section title to read it.*
 ```
 The index note is what `run_research_pipeline` returns. The existing `research_topic` tool handler uses `note.id` and `note.title` — both remain valid with the index note.
 ---
 ## Error Handling
 | Scenario | Behaviour |
 |---|---|
 | Outline generation raises | Fall back to single-note synthesis (current behaviour) |
 | Outline JSON unparseable | Fall back to single-note synthesis |
 | Outline returns < 3 sections | Fall back to single-note synthesis |
 | Outline returns > 8 sections | Truncate to 8, continue |
 | A section synthesis raises | Log warning, skip that section; continue with remaining |
 | All section syntheses fail | Fall back to single-note synthesis |
 | A section note DB save fails | Log warning, skip from index; index note still created |
 | No sources fetched | Raise `ValueError` as today — unchanged |
 The fallback in every case is the current single-note pipeline. Research never silently produces nothing.
 ---
 ## What Is NOT Changing
 - Public function signature of `run_research_pipeline`
 - Sub-query generation (`_generate_sub_queries`)
 - SearXNG search and URL fetching
 - `_search_searxng`, `_search_searxng_images`, `fetch_url_content`
 - The `research_topic` tool definition and handler in `tools.py`
 - The `quick_capture` research path
 - Any frontend component
@@ -0,0 +1,278 @@
 # Web Voice Overlay Polish — Implementation Spec
 > **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:** Ship the dormant `VoiceOverlay` component by mounting it, wiring the Space bar shortcut, and replacing push-to-talk with click-to-toggle silence detection.
 **Architecture:** A new `useSilenceDetector` composable wraps the Web Audio API `AnalyserNode` and fires a callback when sustained silence is detected. `VoiceOverlay` coordinates `useVoiceRecorder` and `useSilenceDetector`, switching from hold-to-record to click-to-toggle. `App.vue` mounts the overlay and adds the Space bar handler.
 **Tech Stack:** Vue 3 Composition API, Web Audio API (`AnalyserNode`), existing `useVoiceRecorder` / `useVoiceAudio` composables, TypeScript.
 ---
 ## File Map
 | Action | Path |
 |--------|------|
 | Create | `frontend/src/composables/useSilenceDetector.ts` |
 | Modify | `frontend/src/composables/useVoiceRecorder.ts` |
 | Modify | `frontend/src/components/VoiceOverlay.vue` |
 | Modify | `frontend/src/App.vue` |
 ---
 ## Task 1: `useSilenceDetector` composable
 **Files:**
 - Create: `frontend/src/composables/useSilenceDetector.ts`
 ### Interface
 ```ts
 export interface SilenceDetectorOptions {
  thresholdDb?: number       // default -40
  silenceDurationMs?: number // default 1500
  minRecordingMs?: number    // default 500
 }
 export function useSilenceDetector(options?: SilenceDetectorOptions): {
  amplitude: Readonly<Ref<number>>   // 0–1, for visualization
  start(stream: MediaStream, onSilence: () => void): void
  stop(): void
 }
 ```
 ### Behaviour
 - `start(stream, onSilence)`:
  1. Creates `AudioContext`
  2. `createMediaStreamSource(stream)` → connects to `AnalyserNode` (fftSize 256)
  3. Records `startedAt = Date.now()`
  4. Starts a `setInterval` at 100ms that:
     - Calls `analyser.getByteFrequencyData(dataArray)`
     - Computes RMS amplitude → maps to 0–1 range for `amplitude.value`
     - Converts to approximate dB: `db = 20 * log10(rms)` (clamp to -100 when rms === 0)
     - If `db < thresholdDb`: increments `silenceMs += 100`; else resets `silenceMs = 0`
     - If `silenceMs >= silenceDurationMs` AND `Date.now() - startedAt >= minRecordingMs`: clears interval, fires `onSilence()`
 - `stop()`: clears interval, closes `AudioContext`, resets `amplitude.value = 0`
 - Safe to call `stop()` multiple times (guard with null check)
 - `amplitude` resets to 0 after `stop()`
 ### Full implementation
 ```ts
 import { ref, readonly } from 'vue'
 export interface SilenceDetectorOptions {
  thresholdDb?: number
  silenceDurationMs?: number
  minRecordingMs?: number
 }
 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) {
    stop()
    audioCtx = new AudioContext()
    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() {
    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 }
 }
 ```
 - [ ] Write the file exactly as above
 - [ ] Verify TypeScript compiles: `cd frontend && npx tsc --noEmit`
 - [ ] Commit: `git add frontend/src/composables/useSilenceDetector.ts && git commit -m "feat: add useSilenceDetector composable"`
 ---
 ## Task 2: Expose `stream` from `useVoiceRecorder`
 **Files:**
 - Modify: `frontend/src/composables/useVoiceRecorder.ts`
 Change the `stream` local variable to a `Ref<MediaStream | null>` and export it as readonly.
 - [ ] Change `let stream: MediaStream | null = null` to `const streamRef = ref<MediaStream | null>(null)`
 - [ ] Replace all `stream` assignments with `streamRef.value`:
  - `stream = await navigator.mediaDevices.getUserMedia(...)` → `streamRef.value = await ...`
  - `stream?.getTracks().forEach(...)` → `streamRef.value?.getTracks().forEach(...)`
  - `stream = null` → `streamRef.value = null`
 - [ ] Add `stream: readonly(streamRef)` to the return object
 - [ ] Verify TypeScript: `npx tsc --noEmit`
 - [ ] Commit: `git add frontend/src/composables/useVoiceRecorder.ts && git commit -m "feat: expose stream ref from useVoiceRecorder"`
 ---
 ## Task 3: Wire `VoiceOverlay` — silence detection + click-to-toggle
 **Files:**
 - Modify: `frontend/src/components/VoiceOverlay.vue`
 ### Script changes
 - [ ] Import `useSilenceDetector` at the top of `<script setup>`
 - [ ] Add `const silenceDetector = useSilenceDetector()` after the existing composable instantiations
 - [ ] In `startPtt()`: after `phase.value = 'recording'`, add:
  ```ts
  if (recorder.stream.value) {
    silenceDetector.start(recorder.stream.value, stopPtt)
  }
  ```
 - [ ] In `stopPtt()`: add `silenceDetector.stop()` as the first line (before the guard check)
 - [ ] In `cancelAll()`: add `silenceDetector.stop()` after `recorder.stopRecording().catch(() => {})`
 ### Button: click-to-toggle
 Replace the PTT mouse/touch handlers on `.voice-ptt-btn` with click-to-toggle logic:
 - [ ] Remove `@mousedown.prevent="startPtt"` and `@mouseup.prevent="stopPtt"`
 - [ ] Remove `@touchstart.prevent="startPtt"` and `@touchend.prevent="stopPtt"`
 - [ ] Replace `@click.prevent="phase === 'error' ? (phase = 'idle') : undefined"` with:
  ```html
  @click.prevent="onBtnClick"
  ```
 - [ ] Add `onBtnClick` function in script:
  ```ts
  function onBtnClick() {
    if (phase.value === 'error') { phase.value = 'idle'; return }
    if (phase.value === 'recording') { stopPtt(); return }
    if (phase.value === 'idle') { startPtt() }
  }
  ```
 - [ ] Update `aria-label` and `title` on the button:
  - `aria-label`: `phase === 'recording' ? 'Click to stop' : 'Click to speak'`
  - `title`: `phase === 'recording' ? 'Click to stop or wait for silence' : 'Click or press Space to speak'`
 ### Amplitude visualization during recording
 Inside the button, when `phase === 'recording'`, replace the static stop icon with animated amplitude bars:
 - [ ] Replace the recording SVG block:
  ```html
  <svg v-else-if="phase === 'recording'" ...>...</svg>
  ```
  with:
  ```html
  <span v-else-if="phase === 'recording'" class="voice-amp-bars">
    <span
      v-for="n in 3"
      :key="n"
      class="voice-amp-bar"
      :style="{ transform: `scaleY(${0.3 + silenceDetector.amplitude.value * (0.4 + n * 0.15)})` }"
    ></span>
  </span>
  ```
 ### Hint label
 - [ ] Change the idle hint from `Hold <kbd>Space</kbd> or tap` to `Tap or press <kbd>Space</kbd>`
 ### CSS for amplitude bars
 - [ ] Add to `<style scoped>`:
  ```css
  .voice-amp-bars {
    display: flex;
    gap: 3px;
    align-items: center;
    height: 22px;
  }
  .voice-amp-bar {
    width: 4px;
    height: 18px;
    background: #fff;
    border-radius: 2px;
    transform-origin: center;
    transition: transform 0.08s ease;
  }
  ```
 - [ ] Verify TypeScript: `npx tsc --noEmit`
 - [ ] Commit: `git add frontend/src/components/VoiceOverlay.vue && git commit -m "feat: click-to-toggle silence detection in VoiceOverlay"`
 ---
 ## Task 4: Mount overlay and wire Space bar in `App.vue`
 **Files:**
 - Modify: `frontend/src/App.vue`
 ### Mount VoiceOverlay
 - [ ] Add import at top of `<script setup>`:
  ```ts
  import VoiceOverlay from '@/components/VoiceOverlay.vue'
  ```
 - [ ] Add `<VoiceOverlay />` inside the `<template v-if="authStore.isAuthenticated">` block, just before `<ToastNotification />`:
  ```html
  <VoiceOverlay />
  <ToastNotification />
  ```
 ### Space bar handler
 - [ ] In `onGlobalKeydown`, add a `Space` case inside the `switch (e.key)` block (after the existing cases), only fires when `!isInputActive()`:
  ```ts
  case ' ':
    e.preventDefault()
    document.dispatchEvent(new CustomEvent('voice:ptt-toggle'))
    break
  ```
 ### Shortcuts panel label
 - [ ] Update the Space shortcut description from `Hold to speak (voice, when enabled)` to `Tap to speak (voice, when enabled)`
 - [ ] Verify TypeScript: `npx tsc --noEmit`
 - [ ] Verify full build: `npm run build`
 - [ ] Commit: `git add frontend/src/App.vue && git commit -m "feat: mount VoiceOverlay and wire Space bar shortcut"`
@@ -0,0 +1,144 @@
 # Knowledge View Task Consolidation — Design Spec
 ## Goal
 Consolidate tasks into the Knowledge view as a card type, deprecate the standalone `/notes` and `/tasks` list views, and simplify navigation. The Knowledge view becomes the single hub for all content types: notes, tasks, people, places, and lists.
 ## Architecture
 The Knowledge view already renders notes, people, places, and lists as typed cards in a filterable grid with a sidebar. Tasks are added as a fifth card type using the same two-tier pagination system (ID pre-fetch → content batch). The backend knowledge endpoints (`/api/knowledge/ids`, `/api/knowledge/batch`, `/api/knowledge/counts`) are extended to include tasks. No changes to the note/task CRUD API.
 ## Task Cards
 Task cards follow the same layout as other knowledge cards:
 - **Left accent strip**: distinct color for tasks (e.g. `#a78bfa` purple to differentiate from note indigo)
 - **Type badge**: "Task" in top-right corner
 - **Card body**:
  - Title (2-line clamp)
  - Status badge: `todo` / `in_progress` / `done` / `cancelled` — styled with existing status colors from theme (`--color-status-*`)
  - Priority indicator: shown only when priority is not `none` — uses existing priority colors (`--color-priority-*`)
  - Due date: shown when set, with overdue styling (`--color-overdue`) when past and status is not `done`/`cancelled`
 - **Card footer**: tags (up to 3) + last-modified date — identical to other card types
 Clicking a task card navigates to `/tasks/:id/edit` (same as today).
 ## Filter Sidebar Changes
 The type filter section gains a "Tasks" button:
 ```
 Type
 ──────────
 [All]           127
 [Notes]          84
 [Tasks]          22
 [People]          8
 [Places]          5
 [Lists]           8
 ```
 The filter value for tasks is `type=task`. The backend already stores tasks as notes with `is_task=True`; the knowledge endpoints need to map the `type=task` filter to `is_task=True`.
 ## New Note Button Interaction
 Current: click "New note" to create a note; chevron expands a dropdown with Note/Person/Place/List.
 New behavior:
 1. **Click "New note"** (when collapsed) → expands to reveal type options: Task, Person, Place, List. The main button label does not change.
 2. **Click "New note"** again (when expanded) → navigates to `/notes/new` (generic note).
 3. **Click any type option** → navigates to `/notes/new?type=<type>` (for task: `/notes/new?type=task`, which is equivalent to `/tasks/new`).
 4. **Click outside** → collapses the dropdown.
 This replaces the current chevron split-button pattern with a simpler toggle. The dropdown items are: Task, Person, Place, List (no "Note" item in the dropdown — clicking the button itself creates a note).
 ## Route Changes
 ### Redirects
 | Old route | New behavior |
 |-----------|-------------|
 | `/notes` | 302 redirect → `/` (Knowledge view) |
 | `/tasks` | 302 redirect → `/` (Knowledge view) |
 ### Preserved routes (no change)
 | Route | Purpose |
 |-------|---------|
 | `/notes/:id` | Note viewer |
 | `/notes/:id/edit` | Note editor |
 | `/notes/new` | New note (with optional `?type=` param) |
 | `/tasks/:id/edit` | Task editor |
 | `/tasks/new` | New task |
 ### Router implementation
 Add redirect entries in the router config:
 ```ts
 { path: '/notes', redirect: '/' },
 { path: '/tasks', redirect: '/' },
 ```
 ### Navigation
 Remove from `AppHeader.vue`:
 - "Tasks" nav link (`<router-link to="/tasks">`)
 - The `/tasks` entry in both desktop nav-center and mobile menu
 Remove from `AppHeader.vue` (already done — `/notes` was removed in a prior change, but verify).
 ### Deleted files
 - `frontend/src/views/NotesListView.vue`
 - `frontend/src/views/TasksListView.vue`
 - `frontend/src/stores/notes.ts` (if only used by NotesListView)
 - `frontend/src/stores/tasks.ts` (if only used by TasksListView)
 Verify no other components import from these before deleting. The note/task viewer and editor screens import from `api/client.ts` directly, not from the list stores.
 ## Backend Changes
 ### `/api/knowledge/ids`
 Accept `type=task` as a valid filter. When `type=task`, query `notes` table with `is_task = True`. When `type` is not set (all), include tasks in results alongside notes/people/places/lists.
 ### `/api/knowledge/batch`
 Return task-specific fields for items where `is_task = True`:
 - `status`: todo / in_progress / done / cancelled
 - `priority`: none / low / normal / high
 - `due_date`: ISO date string or null
 These are already columns on the `Note` model — just include them in the batch response when the item is a task.
 ### `/api/knowledge/counts`
 Add `task` to the counts response:
 ```json
 { "note": 84, "task": 22, "person": 8, "place": 5, "list": 8, "total": 127 }
 ```
 ### `/api/knowledge/tags`
 No change — tasks already have tags on the same `Note` model.
 ## Keyboard Shortcuts
 Remove from `App.vue` `onGlobalKeydown`:
 - `case "t": router.push("/tasks/new")` — keep this, it still works
 - `case "g"` sequence `case "t": router.push("/tasks")` — change to `router.push("/")` (direct navigation, don't rely on redirect)
 Update shortcuts overlay panel text if it references "Tasks list".
 ## No API Endpoint Changes
 All existing REST endpoints remain:
 - `GET/POST /api/notes` — notes CRUD
 - `GET/POST /api/tasks` — tasks CRUD  
 - `PATCH /api/notes/:id`, `PATCH /api/tasks/:id`
 - `DELETE /api/notes/:id`, `DELETE /api/tasks/:id`
 MCP tools (`fable_create_task`, `fable_list_tasks`, etc.) are unaffected.
@@ -0,0 +1,249 @@
 # Modern Fable — Visual Identity Design Spec
 ## Goal
 Replace the generic "competent dark-mode Vue app" aesthetic with a distinctive visual identity that is unmistakably Fabled Assistant. The design language evolves from "Illuminated Transcript" to "Modern Fable" — keeping the scholarly DNA but adding personality through color, typography, interaction, and card design that no other app has.
 ## Color Palette
 Shift from indigo (`#6366f1`) to deep violet + muted gold.
 ### Dark theme
 | Role | Old | New | Usage |
 |------|-----|-----|-------|
 | Primary | `#818cf8` | `#a78bfa` | Text accents, active states, tags, links |
 | Primary solid | `#6366f1` | `#7c3aed` | Buttons, gradients, accent strips |
 | Primary deep | `#4f46e5` | `#5b21b6` | Gradient endpoints, hover states |
 | Accent (warm) | — | `#d4a017` | Due dates, event times, counts, temporal data |
 | Accent light | — | `#e8c45a` | Amber hover states |
 | Background | `#111113` | `#0f0f14` | Slightly deeper, more dramatic |
 | Surface | `#1a1b22` | `#16161f` | Cards, panels |
 | Card bg | `#1e1e27` | `#1a1a24` | Card interiors |
 | Border | `rgba(99,102,241,0.10)` | `rgba(124,58,237,0.12)` | Violet-tinted borders |
 | Text | `#e4e4f0` | `#e4e4f0` | Unchanged |
 | Text muted | `#52526a` | `#52526a` | Unchanged |
 ### Light theme
 | Role | Old | New |
 |------|-----|-----|
 | Primary | `#6366f1` | `#7c3aed` |
 | Primary text | `#4f46e5` | `#5b21b6` |
 | Accent | — | `#b8860b` (darker gold for light bg) |
 | Tag bg | `#ede9fe` | `#ede5ff` |
 | Tag text | `#4f46e5` | `#6d28d9` |
 ### Semantic color rules
 - **Violet = structural** — navigation, type badges, status indicators, card accents, CTA buttons
 - **Amber/gold = temporal** — due dates, event times, countdown values, "overdue" states, calendar dot, relative timestamps
 - This duality is a core brand principle: violet organizes, amber marks time
 ### Logo update
 Update `AppLogo.vue` SVG fill to use the new violet gradient (`#7c3aed` → `#5b21b6`) instead of the current indigo values.
 ## Card Design — Type DNA
 Each content type gets a distinct visual signature recognizable at a glance without reading the badge.
 ### Shared card structure
 - Background: `var(--color-surface)`
 - Border: `1px solid` with type-tinted color at low opacity
 - Border-radius: `var(--radius-lg)` (14px)
 - Padding: 14px
 - Hover: translateY(-2px) + violet shadow bloom (`0 8px 24px rgba(124,58,237,0.15)`)
 ### Type-specific signatures
 **Note** (`note`)
 - Top edge: full-width 3px gradient bar (`#7c3aed` → `#a78bfa`)
 - Border tint: `rgba(124,58,237,0.12)`
 - Badge color: `#a78bfa`
 **Task** (`task`)
 - Top edge: half-width 3px gradient bar (`#d4a017` → transparent`), left-aligned — partial bar suggests "in progress"
 - Border tint: `rgba(212,160,23,0.10)`
 - Badge color: `#d4a017`
 - Status badge inline with type badge row
 - Due date in amber; overdue in `--color-overdue` (red)
 **Person** (`person`)
 - Top edge: none
 - Corner accent: subtle 60px quarter-circle in top-right (`rgba(16,185,129,0.06)`)
 - Border tint: `rgba(16,185,129,0.10)`
 - Badge color: `#34d399`
 **Place** (`place`)
 - Top edge: none
 - Corner accent: subtle 60px quarter-circle in top-right (`rgba(245,158,11,0.06)`)
 - Border tint: `rgba(245,158,11,0.10)`
 - Badge color: `#fbbf24`
 **List** (`list`)
 - Top edge: full-width 3px gradient bar (`#38bdf8` → `#7dd3fc`)
 - Border tint: `rgba(56,189,248,0.10)`
 - Badge color: `#7dd3fc`
 - Progress bar beneath checkboxes
 ### Card hover state
 All cards share the same hover treatment:
 ```css
 .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);
 }
 ```
 ## Navigation — Signature Header
 Replace the flat nav links with a pill-grouped tab bar.
 ### Structure
 ```
 [Logo + "Fabled"]  [  Knowledge | Chat | Briefing | Calendar | News | Projects  ]  [status · ? · ☀ · ⚙ · user]
 ```
 ### Brand in header
 - Logo: `AppLogo` SVG at 28px with new violet gradient
 - Text: "Fabled" only (not "Fabled Assistant") — Fraunces italic, `#c4b0f0`, 15px
 - The full name "Fabled Assistant" appears on the login page and Settings; the header uses the short form
 ### Tab bar
 - Container: `rgba(124,58,237,0.06)` background, `border-radius: 10px`, 3px padding
 - Inactive tabs: transparent background, `color: var(--color-text-muted)`
 - Active tab: `rgba(124,58,237,0.2)` background, `border-radius: 8px`, `color: #c4b5fd`, soft box-shadow glow `0 0 12px rgba(124,58,237,0.2)`
 - Hover (inactive): `rgba(124,58,237,0.08)` background
 - Transition: background 0.15s, color 0.15s
 ### Header background
 Subtle gradient: `linear-gradient(180deg, var(--color-surface), var(--color-bg))` with a bottom border of `rgba(124,58,237,0.08)`. Creates depth without being heavy.
 ### Mobile
 On mobile (< 768px), the pill bar collapses into the existing hamburger dropdown menu. The dropdown gets the same violet active styling.
 ## Typography — Fraunces as Narrator
 Fraunces italic becomes the "narrator's voice" of the application — the assistant speaking through the UI. System UI font remains for body text and interactive elements.
 ### Where Fraunces is used
 | Element | Style | Example |
 |---------|-------|---------|
 | View titles | Fraunces italic, 20-24px, `#c4b0f0` | *Knowledge*, *Chat*, *Briefing* |
 | Sidebar section labels | Fraunces italic, 11px, `var(--color-primary)` | *Filter*, *Tags*, *Sort* |
 | Empty states | Fraunces italic, 13-15px, `#d4a017` | *"Every story starts with a blank page."* |
 | Card headings (h1/h2/h3) | Fraunces, non-italic, 600 weight | Existing behavior, unchanged |
 | Briefing greeting | Fraunces italic, 16px | *"Good morning, Bryan"* |
 ### Where Fraunces is NOT used
 - Navigation tab labels (system font, 12-13px)
 - Buttons and form labels
 - Card body text, snippets, metadata
 - Toast messages, error text
 ### Empty state voice
 Each major view gets a distinctive empty state message in Fraunces italic, amber color:
 - Knowledge: *"Your story is unwritten. Create your first note to begin."*
 - Chat: *"Start a conversation."*
 - Calendar: *"No events ahead. A quiet chapter."*
 - Briefing (no briefing yet): *"Your daily briefing will appear here each morning."*
 ## Living Details
 Small touches that accumulate into a distinctive feel.
 ### Glow interactions
 - **Buttons**: Primary buttons (`btn-send`, `btn-new-note`, CTAs) get a violet glow on hover: `box-shadow: 0 0 16px rgba(124,58,237,0.35)`
 - **Focus ring**: Change from current `color-mix` to a violet glow: `0 0 0 2px rgba(124,58,237,0.4)`
 - **Active nav tab**: Soft glow behind the active pill (see Navigation section)
 ### Amber for temporal data
 Consistently use `#d4a017` (dark theme) for all time-related information:
 - Due dates on task cards
 - Event times on calendar chips
 - "3d ago" timestamps on cards
 - Overdue badge in the today bar
 - Countdown/relative time in briefing
 This creates a visual language: when you see amber, it's about *when*.
 ### Card hover bloom
 Cards lift and emit a violet shadow on hover (see Card Design section). The shadow color matches the card's type accent at very low opacity for a subtle differentiation.
 ### Status dot pulse
 The Ollama status indicator in the header gains a CSS pulse animation when the model is loaded:
 ```css
@keyframes status-pulse {
  0%, 100% { box-shadow: 0 0 4px rgba(74,222,128,0.4); }
  50% { box-shadow: 0 0 10px rgba(74,222,128,0.6); }
 }
 ```
 Pulse only when status is "loaded" (green). Offline (red) and loading (amber) are static.
 ### Scroll edge fades
 Top and bottom edges of scrollable areas (card grid, chat messages, sidebar tag list) get a gradient mask that fades content into the background. 20px height, using `mask-image: linear-gradient(...)`.
 ### Sidebar section dividers
 Replace flat `border-bottom` between filter sections with a centered ornamental divider:
 ```css
 .filter-section + .filter-section::before {
  content: '·';
  display: block;
  text-align: center;
  color: rgba(124,58,237,0.3);
  font-size: 1.2rem;
  letter-spacing: 0.5em;
  padding: 8px 0;
 }
 ```
 Three centered dots (` · · · `) in faint violet. Subtle but distinctive.
 ### Scrollbar
 Keep the current thin scrollbar but update the color from indigo to violet:
 ```css
 ::-webkit-scrollbar-thumb {
  background: rgba(124,58,237,0.25);
 }
 ```
 ## Files Changed
 | File | Change |
 |------|--------|
 | `frontend/src/assets/theme.css` | Full palette update (both light and dark), scrollbar color |
 | `frontend/src/components/AppLogo.vue` | SVG fill gradient update |
 | `frontend/src/components/AppHeader.vue` | Pill-grouped nav tabs, brand shortening, header gradient, status pulse |
 | `frontend/src/views/KnowledgeView.vue` | Card type DNA (gradient bars, corner accents), hover bloom, section dividers, empty state text, scroll fades, Fraunces view title |
 | `frontend/src/components/ChatPanel.vue` | Scroll fade on messages, empty state text |
 | `frontend/src/views/CalendarView.vue` | Empty state text, amber event times |
 | `frontend/src/views/BriefingView.vue` | Empty state text, Fraunces greeting |
 | `frontend/src/views/ChatView.vue` | (uses ChatPanel — inherits changes) |
 | `frontend/src/App.vue` | Update any global styles referencing old indigo values |
 ## What Does NOT Change
 - Overall layout structure (sidebar + content + optional graph panel)
 - Chat bubble design (user transparent, assistant border-left + shadow)
 - TipTap editor styling
 - Settings view layout
 - Backend — zero changes
 - Mobile layout patterns
@@ -25,6 +25,15 @@ function startAppServices() {
  settingsStore.checkVoiceStatus();
  // Sync browser timezone to the server on every login/page load.
  apiPut("/api/settings", { user_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone }).catch(() => {});
  // Re-check voice status when the tab becomes visible again (model may
  // have finished loading while the user was away).
  document.addEventListener("visibilitychange", onVisibilityChange);
 }
 function onVisibilityChange() {
  if (document.visibilityState === "visible" && authStore.isAuthenticated) {
    settingsStore.checkVoiceStatus();
  }
 }
 function stopAppServices() {
@@ -81,7 +90,7 @@ function onGlobalKeydown(e: KeyboardEvent) {
    switch (e.key) {
      case "h": router.push("/"); break;
      case "n": router.push("/notes"); break;
-      case "t": router.push("/tasks"); break;
+      case "t": router.push("/"); break;
      case "p": router.push("/projects"); break;
      case "c": router.push("/chat"); break;
      case "g": router.push("/graph"); break;
@@ -150,6 +159,7 @@ watch(
 onUnmounted(() => {
  document.removeEventListener("keydown", onGlobalKeydown);
  document.removeEventListener("visibilitychange", onVisibilityChange);
  stopAppServices();
 });
 </script>
@@ -192,7 +202,7 @@ onUnmounted(() => {
                <kbd class="shortcut-key">g</kbd>
                <span class="shortcut-key-sep">+</span>
                <kbd class="shortcut-key">t</kbd>
-                <span class="shortcut-desc">Tasks</span>
+                <span class="shortcut-desc">Knowledge (tasks)</span>
              </div>
              <div class="shortcut-row">
                <kbd class="shortcut-key">g</kbd>
@@ -269,10 +279,6 @@ onUnmounted(() => {
                <kbd class="shortcut-key">Enter</kbd>
                <span class="shortcut-desc">New line</span>
              </div>
              <div class="shortcut-row">
                <kbd class="shortcut-key">Space</kbd>
                <span class="shortcut-desc">Hold to speak (voice, when enabled)</span>
              </div>
            </div>
          </div>
        </div>
@@ -649,9 +649,10 @@ export const getVoiceStatus = () => apiGet<VoiceStatusResult>('/api/voice/status
 export const getVoiceList = () =>
  apiGet<{ voices: VoiceEntry[] }>('/api/voice/voices').then(r => r.voices)
-export async function transcribeAudio(blob: Blob): Promise<{ transcript: string; duration_ms: number }> {
+export async function transcribeAudio(blob: Blob, context?: string): Promise<{ transcript: string; duration_ms: number }> {
  const form = new FormData()
  form.append('audio', blob, 'audio.webm')
  if (context) form.append('context', context)
  const res = await fetch('/api/voice/transcribe', { method: 'POST', body: form })
  if (!res.ok) {
    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }))
@@ -10,17 +10,17 @@
  --color-text-muted: #999999;
  --color-border: #dddde8;
  --color-input-border: #c8c8d8;
-  --color-primary: #6366f1;
+  --color-primary: #7c3aed;
  --color-danger: #d93025;
-  --color-tag-bg: #ede9fe;
+  --color-tag-bg: #ede5ff;
-  --color-tag-text: #4f46e5;
+  --color-tag-text: #6d28d9;
  --color-shadow: rgba(0, 0, 0, 0.08);
  --color-toast-success: #34a853;
  --color-toast-error: #d93025;
  --color-status-todo: #5f6368;
  --color-status-todo-bg: #e8eaed;
-  --color-status-in-progress: #6366f1;
+  --color-status-in-progress: #7c3aed;
-  --color-status-in-progress-bg: #ede9fe;
+  --color-status-in-progress-bg: #ede5ff;
  --color-status-done: #34a853;
  --color-status-done-bg: #e6f4ea;
  --color-priority-low: #5f9ea0;
@@ -44,38 +44,42 @@
  --color-bubble-user-bg: rgba(0, 0, 0, 0.04);
  --color-bubble-user-border: rgba(0, 0, 0, 0.10);
  --color-bubble-user-text: #3a3a4a;
-  --color-bubble-asst-shadow: 0 2px 16px rgba(99, 102, 241, 0.10), 0 1px 4px rgba(0, 0, 0, 0.06);
+  --color-bubble-asst-shadow: 0 2px 16px rgba(124, 58, 237, 0.10), 0 1px 4px rgba(0, 0, 0, 0.06);
  --radius-sm: 6px;
  --radius-md: 12px;
  --radius-lg: 18px;
  --radius-pill: 9999px;
-  --focus-ring: 0 0 0 2px color-mix(in srgb, var(--color-primary) 40%, transparent);
+  --focus-ring: 0 0 0 2px rgba(124, 58, 237, 0.4);
  /* Layout */
  --page-max-width: 1200px;
  --page-padding-x: 1rem;
  --sidebar-width: 260px;
  --color-accent-warm: #b8860b;
  --color-accent-warm-light: #d4a017;
  --color-primary-solid: #7c3aed;
  --color-primary-deep: #5b21b6;
 }
 [data-theme="dark"] {
-  --color-bg: #111113;
+  --color-bg: #0f0f14;
-  --color-bg-secondary: #18181f;
+  --color-bg-secondary: #16161f;
-  --color-bg-card: #1e1e27;
+  --color-bg-card: #1a1a24;
-  --color-surface: #1a1b22;
+  --color-surface: #16161f;
  --color-text: #e4e4f0;
  --color-text-secondary: #8888a8;
  --color-text-muted: #52526a;
-  --color-border: rgba(99, 102, 241, 0.10);
+  --color-border: rgba(124, 58, 237, 0.12);
-  --color-input-border: rgba(99, 102, 241, 0.22);
+  --color-input-border: rgba(124, 58, 237, 0.22);
-  --color-primary: #818cf8;
+  --color-primary: #a78bfa;
  --color-danger: #f44336;
  --color-tag-bg: #2a2a45;
-  --color-tag-text: #a5b4fc;
+  --color-tag-text: #c4b5fd;
  --color-shadow: rgba(0, 0, 0, 0.4);
  --color-toast-success: #4caf50;
  --color-toast-error: #f44336;
  --color-status-todo: #9aa0a6;
  --color-status-todo-bg: #2a2a35;
-  --color-status-in-progress: #818cf8;
+  --color-status-in-progress: #a78bfa;
  --color-status-in-progress-bg: #2a2a45;
  --color-status-done: #4caf50;
  --color-status-done-bg: #1b3a20;
@@ -88,19 +92,23 @@
  --color-wikilink: #c4b5fd;
  --color-wikilink-bg: #2a1a45;
  --color-overdue: #f44336;
-  --color-code-bg: #16161d;
+  --color-code-bg: #12121a;
-  --color-code-inline-bg: #1e1e2d;
+  --color-code-inline-bg: #1a1a2a;
-  --color-table-stripe: #16161e;
+  --color-table-stripe: #14141e;
  --color-success: #4ade80;
  --color-warning: #facc15;
-  --color-input-bar-bg: #1e1e27;
+  --color-input-bar-bg: #1a1a24;
  --color-input-bar-text: #e4e4f0;
  --color-input-bar-placeholder: rgba(228, 228, 240, 0.35);
  --color-overlay: rgba(0, 0, 0, 0.65);
  --color-bubble-user-bg: rgba(255, 255, 255, 0.04);
  --color-bubble-user-border: rgba(255, 255, 255, 0.10);
  --color-bubble-user-text: #b0b0c8;
-  --color-bubble-asst-shadow: 0 4px 28px rgba(99, 102, 241, 0.14), 0 2px 8px rgba(0, 0, 0, 0.4);
+  --color-bubble-asst-shadow: 0 4px 28px rgba(124, 58, 237, 0.14), 0 2px 8px rgba(0, 0, 0, 0.4);
  --color-accent-warm: #d4a017;
  --color-accent-warm-light: #e8c45a;
  --color-primary-solid: #7c3aed;
  --color-primary-deep: #5b21b6;
 }
 *,
@@ -168,11 +176,11 @@ button:not(:disabled):active,
  background: transparent;
 }
 ::-webkit-scrollbar-thumb {
-  background: rgba(99, 102, 241, 0.25);
+  background: rgba(124, 58, 237, 0.25);
  border-radius: 9999px;
 }
 ::-webkit-scrollbar-thumb:hover {
-  background: rgba(99, 102, 241, 0.45);
+  background: rgba(124, 58, 237, 0.45);
 }
 /* Floating inline assist button (teleported to body, cannot be scoped) */
@@ -68,17 +68,19 @@ router.afterEach(() => {
      <!-- Left: brand -->
      <router-link to="/" class="nav-brand">
        <AppLogo :size="34" />
-        Fabled Assistant
+        <span class="brand-text">Fabled</span>
      </router-link>
      <!-- Center: primary navigation (desktop) -->
      <div class="nav-center">
-        <router-link to="/" class="nav-link" :class="{ 'router-link-active': isKnowledgeActive }">Knowledge</router-link>
+        <div class="nav-pill-bar">
-        <router-link to="/chat" :class="['nav-link', { 'router-link-active': isChatActive }]">Chat</router-link>
+          <router-link to="/" class="nav-link" :class="{ 'router-link-active': isKnowledgeActive }">Knowledge</router-link>
-        <router-link to="/briefing" class="nav-link">Briefing</router-link>
+          <router-link to="/chat" :class="['nav-link', { 'router-link-active': isChatActive }]">Chat</router-link>
-        <router-link to="/calendar" class="nav-link">Calendar</router-link>
+          <router-link to="/briefing" class="nav-link">Briefing</router-link>
-        <router-link to="/tasks" class="nav-link">Tasks</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 to="/projects" class="nav-link">Projects</router-link>
        </div>
      </div>
      <!-- Right: status + utilities + gear + user -->
@@ -125,7 +127,6 @@ 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="/tasks" class="nav-link">Tasks</router-link>
      <router-link to="/projects" class="nav-link">Projects</router-link>
      <router-link to="/news" class="nav-link">News</router-link>
      <router-link to="/shared" class="nav-link">Shared</router-link>
@@ -151,40 +152,51 @@ router.afterEach(() => {
 <style scoped>
 .app-header {
-  background: var(--color-bg-secondary);
+  background: linear-gradient(180deg, var(--color-surface), var(--color-bg));
  border-bottom: 1px solid rgba(124, 58, 237, 0.08);
  position: relative;
 }
 .nav {
-  padding: 0.75rem 1.5rem;
+  padding: 0.6rem 1.5rem;
  display: flex;
  align-items: center;
  justify-content: space-between;
  position: relative;
 }
-/* Left */
+/* Left — brand */
 .nav-brand {
  display: flex;
  align-items: center;
-  gap: 0.4rem;
+  gap: 0.45rem;
  font-family: 'Fraunces', Georgia, serif;
  font-optical-sizing: auto;
  font-weight: 600;
  font-size: 1.15rem;
  letter-spacing: -0.01em;
  color: var(--color-primary);
  text-decoration: none;
  flex-shrink: 0;
 }
 .brand-text {
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  font-optical-sizing: auto;
  font-weight: 600;
  font-size: 1rem;
  letter-spacing: -0.01em;
  color: #c4b0f0;
 }
-/* Center — absolutely positioned so it's truly centered regardless of side widths */
+/* Center — pill bar */
 .nav-center {
  position: absolute;
  left: 50%;
  transform: translateX(-50%);
  display: flex;
  align-items: center;
-  gap: 0.1rem;
+}
 .nav-pill-bar {
  display: flex;
  align-items: center;
  gap: 2px;
  background: rgba(124, 58, 237, 0.06);
  border-radius: 10px;
  padding: 3px;
 }
 /* Right */
@@ -196,22 +208,22 @@ router.afterEach(() => {
 }
 .nav-link {
-  color: var(--color-text-secondary);
+  color: var(--color-text-muted);
  text-decoration: none;
-  font-size: 0.9rem;
+  font-size: 0.82rem;
-  padding: 0.3rem 0.6rem;
+  padding: 0.3rem 0.75rem;
-  border-radius: var(--radius-sm);
+  border-radius: 8px;
  transition: background 0.15s, color 0.15s;
 }
 .nav-link:hover {
-  color: var(--color-primary);
+  color: var(--color-text-secondary);
-  background: color-mix(in srgb, var(--color-primary) 8%, transparent);
+  background: rgba(124, 58, 237, 0.08);
 }
 .nav-link.router-link-active {
-  color: var(--color-primary);
+  color: #c4b5fd;
  font-weight: 600;
-  box-shadow: inset 0 -2px 0 var(--color-primary);
+  background: rgba(124, 58, 237, 0.2);
-  border-radius: 0;
+  box-shadow: 0 0 12px rgba(124, 58, 237, 0.2);
 }
 /* Status indicator */
@@ -233,7 +245,7 @@ router.afterEach(() => {
  font-weight: 500;
  color: var(--color-text-muted);
 }
-.status-green .status-dot  { background: var(--color-success, #2ecc71); }
+.status-green .status-dot  { background: var(--color-success, #2ecc71); animation: status-pulse 2.5s ease-in-out infinite; }
 .status-yellow .status-dot { background: var(--color-warning, #f59e0b); animation: pulse-dot 2s infinite; }
 .status-orange .status-dot { background: #f97316; }
 .status-red .status-dot    { background: var(--color-danger, #e74c3c); }
@@ -242,6 +254,10 @@ router.afterEach(() => {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.3; }
 }
@keyframes status-pulse {
  0%, 100% { box-shadow: 0 0 4px rgba(74, 222, 128, 0.4); }
  50% { box-shadow: 0 0 10px rgba(74, 222, 128, 0.6); }
 }
 /* Icon buttons (?, theme, gear) */
 .btn-icon {
@@ -368,6 +384,11 @@ router.afterEach(() => {
    min-height: 44px;
    display: flex;
    align-items: center;
    border-radius: 8px;
  }
  .mobile-menu .nav-link.router-link-active {
    background: rgba(124, 58, 237, 0.15);
    box-shadow: none;
  }
  .mobile-user .btn-logout {
    min-height: 36px;
@@ -11,6 +11,12 @@ defineProps<{ size?: number }>();
    :height="size ?? 24"
    aria-hidden="true"
  >
    <defs>
      <linearGradient id="logo-gradient" x1="0" y1="0" x2="1" y2="1">
        <stop offset="0%" stop-color="var(--color-primary-solid)" />
        <stop offset="100%" stop-color="var(--color-primary-deep)" />
      </linearGradient>
    </defs>
    <!-- Book body -->
    <path class="logo-book" d="M4 7 C4 7 8 5 16 6 C24 5 28 7 28 7 L28 26 C28 26 24 24 16 25 C8 24 4 26 4 26 Z" stroke-width="0.5"/>
    <!-- Book spine -->
@@ -37,7 +43,7 @@ defineProps<{ size?: number }>();
 <style scoped>
 .logo-book {
-  fill: var(--color-primary);
+  fill: url(#logo-gradient);
  stroke: color-mix(in srgb, var(--color-primary) 70%, transparent);
 }
 .logo-spine {
@@ -2,8 +2,10 @@
 import { ref, computed, nextTick } from 'vue'
 import { apiGet, transcribeAudio } from '@/api/client'
 import { useVoiceRecorder } from '@/composables/useVoiceRecorder'
 import { useSilenceDetector } from '@/composables/useSilenceDetector'
 import { useChatStore } from '@/stores/chat'
 import { useSettingsStore } from '@/stores/settings'
 import { useToastStore } from '@/stores/toast'
 import type { Note } from '@/types/note'
 const props = withDefaults(defineProps<{
@@ -107,21 +109,46 @@ function removeAttachedNote() {
  attachedNote.value = null
 }
-// ── PTT ───────────────────────────────────────────────────────────────────────
+// ── Voice (click-to-toggle + silence detection) ─────────────────────────────
 const transcribingVoice = ref(false)
 const recorder = useVoiceRecorder()
 const silenceDetector = useSilenceDetector()
-async function startPtt() {
+async function toggleVoice() {
-  if (!voiceEnabled.value || recorder.recording.value) return
+  if (transcribingVoice.value) return
-  await recorder.startRecording()
+  if (recorder.recording.value) {
    await stopRecording()
  } else {
    await startRecording()
  }
 }
-async function stopPtt() {
+async function startRecording() {
  if (!voiceEnabled.value || recorder.recording.value) return
  if (!recorder.isSupported) {
    useToastStore().show('Microphone requires HTTPS or localhost', 'error')
    return
  }
  await recorder.startRecording()
  if (recorder.error.value) {
    useToastStore().show(recorder.error.value, 'error')
    return
  }
  if (recorder.stream.value) {
    silenceDetector.start(recorder.stream.value, () => stopRecording())
  }
 }
 async function stopRecording() {
  silenceDetector.stop()
  if (!recorder.recording.value) return
  transcribingVoice.value = true
  try {
    const blob = await recorder.stopRecording()
-    const { transcript } = await transcribeAudio(blob)
+    // 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
    const { transcript } = await transcribeAudio(blob, lastAssistant)
    if (transcript.trim()) {
      messageInput.value = transcript.trim()
      await nextTick()
@@ -205,16 +232,13 @@ defineExpose({ focus, prefill })
      <!-- PTT mic -->
      <button
-        v-if="voiceEnabled && recorder.isSupported"
+        v-if="voiceEnabled"
        class="btn-icon btn-mic"
        :class="{ 'mic-recording': recorder.recording.value, 'mic-transcribing': transcribingVoice }"
-        @mousedown.prevent="startPtt"
+        @click.prevent="toggleVoice"
        @mouseup.prevent="stopPtt"
        @touchstart.prevent="startPtt"
        @touchend.prevent="stopPtt"
        :disabled="transcribingVoice || !store.chatReady"
-        :title="recorder.recording.value ? 'Release to send' : 'Hold to speak'"
+        :title="recorder.recording.value ? 'Click to stop (or wait for silence)' : 'Click to speak'"
-        aria-label="Push to talk"
+        :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"/>
@@ -367,7 +391,7 @@ defineExpose({ focus, prefill })
  display: flex;
  align-items: center;
  justify-content: center;
-  background: linear-gradient(135deg, #6366f1, #4f46e5);
+  background: linear-gradient(135deg, #7c3aed, #5b21b6);
  color: #fff;
  border: none;
  border-radius: 50%;
@@ -376,7 +400,7 @@ defineExpose({ focus, prefill })
  flex-shrink: 0;
  transition: box-shadow 0.15s;
 }
-.btn-send:hover { box-shadow: 0 0 12px rgba(99, 102, 241, 0.5); }
+.btn-send:hover { box-shadow: 0 0 16px rgba(124, 58, 237, 0.35); }
 .btn-send:disabled { opacity: 0.35; cursor: default; box-shadow: none; }
 .btn-abort-inline {
@@ -299,12 +299,22 @@ defineExpose({ focus, prefill, send })
      <!-- Message list -->
      <div ref="messagesEl" class="messages-container">
        <div class="messages-inner">
-          <ChatMessage
+          <template
-            v-for="msg in store.currentConversation?.messages ?? []"
+            v-for="(msg, index) in store.currentConversation?.messages ?? []"
            :key="msg.id"
-            :message="msg"
+          >
-            @save-as-note="handleSaveAsNote"
+            <!-- Briefing slot separator: shown before a 2nd+ briefing slot message -->
-          />
+            <div
              v-if="briefingMode && index > 0 && msg.role === 'assistant' && msg.metadata?.rss_item_ids"
              class="briefing-slot-separator"
            >
              <span>New Briefing Update</span>
            </div>
            <ChatMessage
              :message="msg"
              @save-as-note="handleSaveAsNote"
            />
          </template>
          <!-- Streaming bubble -->
          <ChatStreamingBubble v-if="store.streaming" />
          <!-- Queued messages -->
@@ -328,7 +338,7 @@ defineExpose({ focus, prefill, send })
          <p
            v-if="!store.currentConversation?.messages.length && !store.streaming"
            class="empty-msg"
-          >Send a message to start the conversation.</p>
+          >Start a conversation.</p>
        </div>
      </div>
@@ -515,6 +525,8 @@ defineExpose({ focus, prefill, send })
  flex: 1;
  overflow-y: auto;
  padding: 1rem;
  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);
 }
 .messages-inner {
  display: flex;
@@ -523,6 +535,28 @@ defineExpose({ focus, prefill, send })
  justify-content: flex-end;
 }
 /* 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;
  background: var(--color-border, #333);
  opacity: 0.5;
 }
 /* Context sidebar */
 .context-sidebar {
  width: 200px;
@@ -714,6 +748,9 @@ defineExpose({ focus, prefill, send })
  font-size: 0.9rem;
  text-align: center;
  padding: 2rem 1rem;
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  color: var(--color-accent-warm, #d4a017);
 }
 /* ── Widget variant ── */
@@ -1,538 +0,0 @@
 <script setup lang="ts">
 /**
 * VoiceOverlay — global floating push-to-talk button.
 *
 * Full flow: record → transcribe → send to voice conv → stream → TTS → play.
 * Manages its own "voice" conversation; does NOT touch the chat store so it
 * never disrupts an open chat session.
 *
 * Space bar toggles PTT when no input field is focused (wired from App.vue via
 * the "voice:ptt-toggle" custom event).
 */
 import { ref, onMounted, onUnmounted, computed } from 'vue'
 import { useVoiceRecorder } from '@/composables/useVoiceRecorder'
 import { useVoiceAudio } from '@/composables/useVoiceAudio'
 import { apiPost, apiSSEStream, getVoiceStatus, transcribeAudio, synthesiseSpeech } from '@/api/client'
 // ─── Voice service availability ──────────────────────────────────────────────
 const voiceEnabled = ref(false)
 async function checkVoice() {
  try {
    const s = await getVoiceStatus()
    voiceEnabled.value = s.enabled && s.stt && s.tts
  } catch { /* feature absent */ }
 }
 // ─── Conversation management ─────────────────────────────────────────────────
 const STORAGE_KEY = 'voice_overlay_conv_id'
 const convId = ref<number | null>(Number(localStorage.getItem(STORAGE_KEY)) || null)
 interface VoiceMessage { role: 'user' | 'assistant'; content: string }
 const messages = ref<VoiceMessage[]>([])
 async function ensureConversation(): Promise<number> {
  if (convId.value) {
    // Verify it still exists
    try {
      await fetch(`/api/chat/conversations/${convId.value}`)
        .then((r) => { if (!r.ok) throw new Error('gone') })
      return convId.value
    } catch {
      convId.value = null
      localStorage.removeItem(STORAGE_KEY)
    }
  }
  const conv = await apiPost<{ id: number }>('/api/chat/conversations', {
    title: 'Voice',
    conversation_type: 'voice',
  })
  convId.value = conv.id
  localStorage.setItem(STORAGE_KEY, String(conv.id))
  return conv.id
 }
 // ─── State machine ────────────────────────────────────────────────────────────
 type Phase = 'idle' | 'recording' | 'transcribing' | 'generating' | 'speaking' | 'error'
 const phase = ref<Phase>('idle')
 const errorMsg = ref('')
 const streamContent = ref('')
 const open = ref(false)
 const isBusy = computed(() => phase.value !== 'idle' && phase.value !== 'error')
 // ─── Composables ─────────────────────────────────────────────────────────────
 const recorder = useVoiceRecorder()
 const audio = useVoiceAudio()
 // ─── Core PTT flow ────────────────────────────────────────────────────────────
 async function startPtt() {
  if (!voiceEnabled.value || isBusy.value) return
  // Stop any in-progress TTS playback before opening the mic
  audio.stop()
  errorMsg.value = ''
  open.value = true
  await recorder.startRecording()
  if (recorder.error.value) {
    phase.value = 'error'
    errorMsg.value = recorder.error.value
    return
  }
  phase.value = 'recording'
 }
 async function stopPtt() {
  if (phase.value !== 'recording') return
  phase.value = 'transcribing'
  let blob: Blob
  try {
    blob = await recorder.stopRecording()
  } catch {
    phase.value = 'error'
    errorMsg.value = 'Recording failed'
    return
  }
  let transcript: string
  try {
    const result = await transcribeAudio(blob)
    transcript = result.transcript.trim()
  } catch {
    phase.value = 'error'
    errorMsg.value = 'Transcription failed'
    return
  }
  if (!transcript) {
    phase.value = 'idle'
    return
  }
  messages.value.push({ role: 'user', content: transcript })
  scrollToBottom()
  // Send to voice conversation
  phase.value = 'generating'
  streamContent.value = ''
  let cid: number
  try {
    cid = await ensureConversation()
  } catch {
    phase.value = 'error'
    errorMsg.value = 'Could not create voice conversation'
    return
  }
  let assistantMessageId: number
  try {
    const resp = await apiPost<{ assistant_message_id: number }>(
      `/api/chat/conversations/${cid}/messages`,
      {
        content: transcript,
        user_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
      }
    )
    assistantMessageId = resp.assistant_message_id
  } catch {
    phase.value = 'error'
    errorMsg.value = 'Failed to send message'
    return
  }
  // Stream the response
  await new Promise<void>((resolve) => {
    const handle = apiSSEStream(
      `/api/chat/conversations/${cid}/generation/stream`,
      (event) => {
        switch (event.event) {
          case 'chunk':
            streamContent.value += event.data.chunk as string
            break
          case 'done':
            handle.close()
            resolve()
            break
          case 'error':
            handle.close()
            resolve()
            break
        }
      }
    )
    // Safety timeout: 3 minutes
    setTimeout(() => { handle.close(); resolve() }, 180_000)
  })
  const responseText = streamContent.value.trim()
  if (responseText) {
    messages.value.push({ role: 'assistant', content: responseText })
    streamContent.value = ''
    scrollToBottom()
  }
  // Synthesise and play
  if (responseText) {
    phase.value = 'speaking'
    try {
      const wavBlob = await synthesiseSpeech(responseText)
      await audio.play(wavBlob)
    } catch {
      // TTS failure is non-critical; show response text
    }
  }
  phase.value = 'idle'
  assistantMessageId // consumed; suppress lint
 }
 function cancelAll() {
  recorder.stopRecording().catch(() => {})
  audio.stop()
  phase.value = 'idle'
  streamContent.value = ''
  errorMsg.value = ''
 }
 // ─── Space bar PTT (event from App.vue) ──────────────────────────────────────
 function onPttToggle() {
  if (!voiceEnabled.value) return
  if (phase.value === 'recording') {
    stopPtt()
  } else if (phase.value === 'idle' || phase.value === 'error') {
    startPtt()
  }
 }
 // ─── Scroll ───────────────────────────────────────────────────────────────────
 const transcriptEl = ref<HTMLElement | null>(null)
 function scrollToBottom() {
  setTimeout(() => {
    if (transcriptEl.value) {
      transcriptEl.value.scrollTop = transcriptEl.value.scrollHeight
    }
  }, 50)
 }
 // ─── Lifecycle ────────────────────────────────────────────────────────────────
 onMounted(() => {
  checkVoice()
  document.addEventListener('voice:ptt-toggle', onPttToggle)
 })
 onUnmounted(() => {
  document.removeEventListener('voice:ptt-toggle', onPttToggle)
  cancelAll()
 })
 </script>
 <template>
  <Teleport to="body">
    <div v-if="voiceEnabled" class="voice-overlay">
      <!-- Expanded transcript panel -->
      <Transition name="panel-slide">
        <div v-if="open && messages.length > 0" class="voice-panel">
          <div class="voice-panel-header">
            <span class="voice-panel-title">Voice</span>
            <button class="voice-panel-close" @click="open = false" aria-label="Close">×</button>
          </div>
          <div class="voice-transcript" ref="transcriptEl">
            <div
              v-for="(msg, i) in messages.slice(-10)"
              :key="i"
              :class="['voice-msg', `voice-msg--${msg.role}`]"
            >{{ msg.content }}</div>
            <!-- Live streaming text -->
            <div v-if="phase === 'generating' && streamContent" class="voice-msg voice-msg--assistant voice-msg--streaming">
              {{ streamContent }}<span class="voice-cursor">▌</span>
            </div>
          </div>
        </div>
      </Transition>
      <!-- PTT button -->
      <div class="voice-btn-wrap">
        <!-- Status label -->
        <div v-if="phase !== 'idle'" class="voice-status-label">
          <span v-if="phase === 'recording'">Recording…</span>
          <span v-else-if="phase === 'transcribing'">Transcribing…</span>
          <span v-else-if="phase === 'generating'">Thinking…</span>
          <span v-else-if="phase === 'speaking'">Speaking…</span>
          <span v-else-if="phase === 'error'" class="voice-error-label">{{ errorMsg || 'Error' }}</span>
        </div>
        <div v-else-if="!open || !messages.length" class="voice-status-label voice-hint">
          Hold <kbd>Space</kbd> or tap
        </div>
        <!-- Cancel button (shown while busy or speaking) -->
        <button
          v-if="isBusy || audio.playing.value"
          class="voice-cancel"
          @click="cancelAll"
          aria-label="Cancel"
          title="Cancel"
        >
          <svg width="13" height="13" viewBox="0 0 24 24" fill="currentColor">
            <path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/>
          </svg>
        </button>
        <!-- Main PTT button -->
        <button
          class="voice-ptt-btn"
          :class="{
            'voice-ptt--recording': phase === 'recording',
            'voice-ptt--busy': phase === 'generating' || phase === 'transcribing',
            'voice-ptt--speaking': phase === 'speaking' || audio.playing.value,
            'voice-ptt--error': phase === 'error',
          }"
          @mousedown.prevent="startPtt"
          @mouseup.prevent="stopPtt"
          @touchstart.prevent="startPtt"
          @touchend.prevent="stopPtt"
          @click.prevent="phase === 'error' ? (phase = 'idle') : undefined"
          :disabled="phase === 'transcribing' || phase === 'generating'"
          :aria-label="phase === 'recording' ? 'Release to send' : 'Hold to speak'"
          :title="phase === 'recording' ? 'Release to send' : 'Hold Space or tap to speak'"
        >
          <!-- Idle: mic icon -->
          <svg v-if="phase === 'idle' || phase === 'error'" width="22" height="22" 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>
          <!-- Recording: waveform / stop icon -->
          <svg v-else-if="phase === 'recording'" width="22" height="22" viewBox="0 0 24 24" fill="currentColor">
            <path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/>
          </svg>
          <!-- Busy: spinner dots -->
          <span v-else-if="phase === 'transcribing' || phase === 'generating'" class="voice-spinner">
            <span></span><span></span><span></span>
          </span>
          <!-- Speaking: sound waves -->
          <svg v-else-if="phase === 'speaking'" width="22" height="22" 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>
        </button>
      </div>
    </div>
  </Teleport>
 </template>
 <style scoped>
 .voice-overlay {
  position: fixed;
  bottom: 2rem;
  right: 1.5rem;
  z-index: 8000;
  display: flex;
  flex-direction: column;
  align-items: flex-end;
  gap: 0.5rem;
  pointer-events: none;
 }
 /* ─── Panel ──────────────────────────────────────────────────────────────── */
 .voice-panel {
  pointer-events: all;
  width: min(320px, 90vw);
  background: var(--color-bg-card);
  border: 1px solid var(--color-border);
  border-radius: 14px;
  box-shadow: 0 8px 32px var(--color-shadow, rgba(0,0,0,0.22));
  overflow: hidden;
  display: flex;
  flex-direction: column;
  max-height: 340px;
 }
 .voice-panel-header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  padding: 0.6rem 0.85rem 0.5rem;
  border-bottom: 1px solid var(--color-border);
  flex-shrink: 0;
 }
 .voice-panel-title {
  font-size: 0.75rem;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 0.07em;
  color: var(--color-primary);
 }
 .voice-panel-close {
  background: none;
  border: none;
  font-size: 1.3rem;
  line-height: 1;
  color: var(--color-text-muted);
  cursor: pointer;
  padding: 0 0.1rem;
 }
 .voice-panel-close:hover { color: var(--color-text); }
 .voice-transcript {
  flex: 1;
  overflow-y: auto;
  padding: 0.65rem 0.85rem;
  display: flex;
  flex-direction: column;
  gap: 0.45rem;
 }
 .voice-msg {
  font-size: 0.875rem;
  line-height: 1.45;
  padding: 0.4rem 0.65rem;
  border-radius: 10px;
  max-width: 88%;
  white-space: pre-wrap;
  word-break: break-word;
 }
 .voice-msg--user {
  align-self: flex-end;
  background: color-mix(in srgb, var(--color-primary) 12%, transparent);
  border: 1px solid color-mix(in srgb, var(--color-primary) 25%, transparent);
  color: var(--color-text);
 }
 .voice-msg--assistant {
  align-self: flex-start;
  background: var(--color-bg-secondary);
  border: 1px solid var(--color-border);
  color: var(--color-text);
 }
 .voice-msg--streaming { opacity: 0.85; }
 .voice-cursor {
  display: inline-block;
  animation: blink 0.9s step-end infinite;
  margin-left: 1px;
  color: var(--color-primary);
 }
@keyframes blink { 0%, 100% { opacity: 1; } 50% { opacity: 0; } }
 /* ─── Button cluster ─────────────────────────────────────────────────────── */
 .voice-btn-wrap {
  pointer-events: all;
  display: flex;
  flex-direction: column;
  align-items: flex-end;
  gap: 0.35rem;
 }
 .voice-status-label {
  font-size: 0.72rem;
  color: var(--color-text-muted);
  background: var(--color-bg-card);
  border: 1px solid var(--color-border);
  border-radius: 6px;
  padding: 0.18rem 0.5rem;
  white-space: nowrap;
  box-shadow: 0 2px 6px var(--color-shadow, rgba(0,0,0,0.12));
 }
 .voice-hint { opacity: 0.7; }
 .voice-hint kbd {
  font-family: ui-monospace, monospace;
  font-size: 0.68rem;
  padding: 0.05rem 0.25rem;
  border: 1px solid var(--color-border);
  border-radius: 3px;
  background: var(--color-bg-secondary);
 }
 .voice-error-label { color: #ef4444; }
 .voice-cancel {
  background: var(--color-bg-card);
  border: 1px solid var(--color-border);
  border-radius: 50%;
  width: 28px;
  height: 28px;
  display: flex;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  color: var(--color-text-muted);
  box-shadow: 0 2px 6px var(--color-shadow, rgba(0,0,0,0.12));
  transition: all 0.15s;
 }
 .voice-cancel:hover { color: #ef4444; border-color: #ef4444; }
 .voice-ptt-btn {
  width: 58px;
  height: 58px;
  border-radius: 50%;
  border: none;
  background: linear-gradient(135deg, #6366f1, #4f46e5);
  color: #fff;
  display: flex;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  box-shadow: 0 4px 16px rgba(99, 102, 241, 0.45);
  transition: transform 0.12s, box-shadow 0.12s, background 0.2s;
  touch-action: none;
  user-select: none;
  flex-shrink: 0;
 }
 .voice-ptt-btn:hover:not(:disabled) {
  transform: scale(1.06);
  box-shadow: 0 6px 20px rgba(99, 102, 241, 0.55);
 }
 .voice-ptt-btn:disabled { opacity: 0.6; cursor: not-allowed; }
 .voice-ptt--recording {
  background: linear-gradient(135deg, #ef4444, #dc2626) !important;
  box-shadow: 0 4px 16px rgba(239, 68, 68, 0.5) !important;
  animation: ptt-pulse 0.9s ease-in-out infinite;
 }
 .voice-ptt--busy {
  background: linear-gradient(135deg, #8b5cf6, #7c3aed) !important;
  box-shadow: 0 4px 16px rgba(139, 92, 246, 0.45) !important;
 }
 .voice-ptt--speaking {
  background: linear-gradient(135deg, #10b981, #059669) !important;
  box-shadow: 0 4px 16px rgba(16, 185, 129, 0.45) !important;
  animation: ptt-pulse 1.4s ease-in-out infinite;
 }
 .voice-ptt--error {
  background: linear-gradient(135deg, #6b7280, #4b5563) !important;
  box-shadow: none !important;
 }
@keyframes ptt-pulse {
  0%, 100% { transform: scale(1); }
  50% { transform: scale(1.08); }
 }
 /* ─── Spinner dots ───────────────────────────────────────────────────────── */
 .voice-spinner {
  display: flex;
  gap: 4px;
  align-items: center;
 }
 .voice-spinner span {
  width: 5px;
  height: 5px;
  border-radius: 50%;
  background: #fff;
  animation: dot-bounce 1.2s ease-in-out infinite;
 }
 .voice-spinner span:nth-child(2) { animation-delay: 0.2s; }
 .voice-spinner span:nth-child(3) { animation-delay: 0.4s; }
@keyframes dot-bounce {
  0%, 80%, 100% { transform: scale(0.7); opacity: 0.5; }
  40% { transform: scale(1); opacity: 1; }
 }
 /* ─── Transition ─────────────────────────────────────────────────────────── */
 .panel-slide-enter-active,
 .panel-slide-leave-active {
  transition: opacity 0.2s ease, transform 0.2s ease;
 }
 .panel-slide-enter-from,
 .panel-slide-leave-to {
  opacity: 0;
  transform: translateY(8px);
 }
 </style>
@@ -0,0 +1,69 @@
 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 }
 }
@@ -86,11 +86,21 @@ export function useStreamingTts(options: UseStreamingTtsOptions): UseStreamingTt
    try {
      blob = await synthesiseSpeech(stripped)
    } catch (e) {
-      console.warn('[StreamingTTS] Synthesis failed, retrying sentence', { sentence: stripped, error: e })
+      const errMsg = e instanceof Error ? e.message : String(e)
      console.warn('[StreamingTTS] Synthesis failed, retrying', {
        chars: stripped.length,
        preview: stripped.slice(0, 80),
        error: errMsg,
      })
      try {
        blob = await synthesiseSpeech(stripped)
      } catch (e2) {
-        console.warn('[StreamingTTS] Retry also failed, skipping sentence', { sentence: stripped, error: e2 })
+        const errMsg2 = e2 instanceof Error ? e2.message : String(e2)
        console.warn('[StreamingTTS] Retry failed, sentence dropped', {
          chars: stripped.length,
          preview: stripped.slice(0, 80),
          error: errMsg2,
        })
      }
    } finally {
      pendingCount.value--
@@ -1,4 +1,4 @@
-import { ref, readonly } from 'vue'
+import { ref, readonly, type Ref } from 'vue'
 /**
 * Push-to-talk recorder wrapping the browser MediaRecorder API.
@@ -15,7 +15,7 @@ export function useVoiceRecorder() {
  let mediaRecorder: MediaRecorder | null = null
  let chunks: Blob[] = []
-  let stream: MediaStream | null = null
+  const streamRef = ref<MediaStream | null>(null)
  let resolveStop: ((blob: Blob) => void) | null = null
  let rejectStop: ((err: Error) => void) | null = null
@@ -28,7 +28,7 @@ export function useVoiceRecorder() {
    if (recording.value) return
    try {
-      stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+      streamRef.value = await navigator.mediaDevices.getUserMedia({ audio: true })
    } catch (e) {
      error.value = 'Microphone access denied'
      return
@@ -41,7 +41,7 @@ export function useVoiceRecorder() {
        ? 'audio/webm'
        : ''
-    mediaRecorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream)
+    mediaRecorder = mimeType ? new MediaRecorder(streamRef.value!, { mimeType }) : new MediaRecorder(streamRef.value!)
    mediaRecorder.ondataavailable = (e) => {
      if (e.data.size > 0) chunks.push(e.data)
@@ -50,8 +50,8 @@ export function useVoiceRecorder() {
    mediaRecorder.onstop = () => {
      const blob = new Blob(chunks, { type: mediaRecorder?.mimeType ?? 'audio/webm' })
      chunks = []
-      stream?.getTracks().forEach((t) => t.stop())
+      streamRef.value?.getTracks().forEach((t) => t.stop())
-      stream = null
+      streamRef.value = null
      recording.value = false
      resolveStop?.(blob)
      resolveStop = null
@@ -88,5 +88,6 @@ export function useVoiceRecorder() {
    isSupported,
    startRecording,
    stopRecording,
    stream: readonly(streamRef) as Readonly<Ref<MediaStream | null>>,
  }
 }
@@ -45,8 +45,7 @@ const router = createRouter({
    },
    {
      path: "/notes",
-      name: "notes",
+      redirect: "/",
      component: () => import("@/views/NotesListView.vue"),
    },
    {
      path: "/notes/new",
@@ -85,8 +84,7 @@ const router = createRouter({
    },
    {
      path: "/tasks",
-      name: "tasks",
+      redirect: "/",
      component: () => import("@/views/TasksListView.vue"),
    },
    {
      path: "/tasks/new",
@@ -28,6 +28,7 @@ export interface Message {
  context_note_id: number | null;
  context_note_title?: string | null;
  tool_calls?: ToolCallRecord[] | null;
  metadata?: Record<string, unknown> | null;
  created_at: string;
  timing?: GenerationTiming;
  thinking?: string;
@@ -15,7 +15,7 @@ const chatStore = useChatStore();
 interface KnowledgeItem {
  id: number;
-  note_type: "note" | "person" | "place" | "list";
+  note_type: "note" | "person" | "place" | "list" | "task";
  title: string;
  snippet: string;
  tags: string[];
@@ -33,6 +33,10 @@ interface KnowledgeItem {
  checked_count?: number;
  list_items?: { text: string; checked: boolean }[];
  body?: string;
  // Task-specific
  status?: string;
  priority?: string;
  due_date?: string;
 }
 interface UpcomingEvent {
@@ -44,7 +48,7 @@ interface UpcomingEvent {
 // ─── Filter state ─────────────────────────────────────────────────────────────
-const activeType = ref<"" | "note" | "person" | "place" | "list">("");
+const activeType = ref<"" | "note" | "person" | "place" | "list" | "task">("");
 const activeTag = ref("");
 const sortMode = ref<"modified" | "created" | "alpha" | "type">("modified");
 const searchQuery = ref("");
@@ -69,7 +73,18 @@ const newNoteMenuOpen = ref(false);
 function createNew(type: string) {
  newNoteMenuOpen.value = false;
-  router.push(type === "note" ? "/notes/new" : `/notes/new?type=${type}`);
+  if (type === "task") {
    router.push("/tasks/new");
  } else {
    router.push(type === "note" ? "/notes/new" : `/notes/new?type=${type}`);
  }
 }
 function onClickOutsideNewNote(e: MouseEvent) {
  const wrap = document.querySelector('.new-note-wrap');
  if (wrap && !wrap.contains(e.target as Node)) {
    newNoteMenuOpen.value = false;
  }
 }
 // ─── Two-tier pagination ──────────────────────────────────────────────────────
@@ -307,8 +322,17 @@ async function toggleListItem(item: KnowledgeItem, index: number) {
 // ─── Navigation helpers ───────────────────────────────────────────────────────
 function isOverdue(item: KnowledgeItem): boolean {
  if (!item.due_date || item.status === 'done' || item.status === 'cancelled') return false;
  return new Date(item.due_date) < new Date(new Date().toDateString());
 }
 function openItem(item: KnowledgeItem) {
-  router.push(`/notes/${item.id}`);
+  if (item.note_type === 'task') {
    router.push(`/tasks/${item.id}`);
  } else {
    router.push(`/notes/${item.id}`);
  }
 }
 function formatDate(iso: string): string {
@@ -344,6 +368,7 @@ function setupObserver() {
 // ─── Lifecycle ────────────────────────────────────────────────────────────────
 onMounted(async () => {
  document.addEventListener('click', onClickOutsideNewNote);
  await reset();
  fetchTags();
  fetchCounts();
@@ -353,6 +378,7 @@ onMounted(async () => {
 });
 onUnmounted(() => {
  document.removeEventListener('click', onClickOutsideNewNote);
  if (searchDebounce) clearTimeout(searchDebounce);
  observer?.disconnect();
 });
@@ -392,10 +418,9 @@ onUnmounted(() => {
      <aside class="filter-panel">
        <!-- New note button -->
        <div class="new-note-wrap">
-          <button class="btn-new-note" @click="createNew('note')">+ New note</button>
+          <button class="btn-new-note" @click="newNoteMenuOpen ? createNew('note') : (newNoteMenuOpen = true)">+ New note</button>
          <button class="btn-new-chevron" @click="newNoteMenuOpen = !newNoteMenuOpen" :class="{ open: newNoteMenuOpen }" title="Create specific type">▾</button>
          <div v-if="newNoteMenuOpen" class="new-note-menu">
-            <button @click="createNew('note')">Note</button>
+            <button @click="createNew('task')">Task</button>
            <button @click="createNew('person')">Person</button>
            <button @click="createNew('place')">Place</button>
            <button @click="createNew('list')">List</button>
@@ -413,11 +438,11 @@ onUnmounted(() => {
            <span v-if="typeCounts.total > 1" class="filter-count">{{ typeCounts.total }}</span>
          </button>
          <button
-            v-for="[val, label, key] in ([['note','Notes','note'],['person','People','person'],['place','Places','place'],['list','Lists','list']] as [string,string,string][])"
+            v-for="[val, label, key] in ([['note','Notes','note'],['task','Tasks','task'],['person','People','person'],['place','Places','place'],['list','Lists','list']] as [string,string,string][])"
            :key="val"
            class="filter-btn"
            :class="{ active: activeType === val }"
-            @click="activeType = (val as '' | 'note' | 'person' | 'place' | 'list')"
+            @click="activeType = (val as '' | 'note' | 'person' | 'place' | 'list' | 'task')"
          >
            <span class="filter-btn-label">{{ label }}</span>
            <span v-if="typeCounts[key as keyof KnowledgeCounts] > 1" class="filter-count">{{ typeCounts[key as keyof KnowledgeCounts] }}</span>
@@ -474,9 +499,8 @@ onUnmounted(() => {
        <!-- Loading / empty -->
        <div v-if="loading && items.length === 0" class="knowledge-empty">Loading…</div>
        <div v-else-if="!loading && items.length === 0" class="knowledge-empty">
-          <p>Nothing here yet.</p>
+          <p v-if="activeType || activeTag || searchQuery" class="empty-hint">No matches. Try clearing the filters.</p>
-          <p v-if="activeType || activeTag || searchQuery" class="empty-hint">Try clearing the filters.</p>
+          <p v-else class="empty-narrator">Your story is unwritten. Create your first note to begin.</p>
          <p v-else class="empty-hint">Start by creating a note, saving a person or place, or making a list.</p>
        </div>
        <!-- Card grid -->
@@ -533,6 +557,26 @@ onUnmounted(() => {
                </span>
              </div>
              <!-- Task specifics -->
              <div v-else-if="item.note_type === 'task'" class="k-card-task">
                <div class="task-badges">
                  <span class="status-badge" :class="`status--${item.status}`">
                    {{ item.status === 'in_progress' ? 'in progress' : item.status }}
                  </span>
                  <span
                    v-if="item.priority && item.priority !== 'none'"
                    class="priority-badge"
                    :class="`priority--${item.priority}`"
                  >{{ item.priority }}</span>
                </div>
                <span
                  v-if="item.due_date"
                  class="task-due"
                  :class="{ 'task-overdue': isOverdue(item) }"
                >{{ formatDate(item.due_date) }}</span>
                <p v-if="item.snippet" class="k-card-snippet">{{ item.snippet }}</p>
              </div>
              <!-- Note snippet -->
              <p v-else-if="item.snippet" class="k-card-snippet">{{ item.snippet }}</p>
            </div>
@@ -652,17 +696,17 @@ onUnmounted(() => {
  gap: 5px;
  padding: 3px 10px;
  border-radius: 20px;
-  background: rgba(99, 102, 241, 0.1);
+  background: rgba(124, 58, 237, 0.1);
-  border: 1px solid rgba(99, 102, 241, 0.2);
+  border: 1px solid rgba(124, 58, 237, 0.2);
  color: var(--color-text);
  text-decoration: none;
  transition: background 0.15s;
 }
-.today-event-chip:hover { background: rgba(99, 102, 241, 0.18); }
+.today-event-chip:hover { background: rgba(124, 58, 237, 0.18); }
 .chip-dot {
  width: 6px; height: 6px;
  border-radius: 50%;
-  background: #6366f1;
+  background: #7c3aed;
  flex-shrink: 0;
 }
 .chip-date { color: var(--color-muted); font-size: 0.78rem; }
@@ -677,7 +721,7 @@ onUnmounted(() => {
  font-size: 0.78rem;
 }
 .today-link {
-  color: var(--color-primary, #6366f1);
+  color: var(--color-primary, #7c3aed);
  text-decoration: none;
  font-weight: 500;
  opacity: 0.85;
@@ -703,11 +747,21 @@ onUnmounted(() => {
  background: var(--color-bg-secondary);
 }
 .filter-section { margin-bottom: 20px; }
 .filter-section + .filter-section::before {
  content: '· · ·';
  display: block;
  text-align: center;
  color: rgba(124, 58, 237, 0.3);
  font-size: 0.9rem;
  letter-spacing: 0.4em;
  padding: 4px 0 12px;
 }
 .filter-label {
-  font-size: 0.7rem;
+  font-family: 'Fraunces', Georgia, serif;
-  text-transform: uppercase;
+  font-style: italic;
-  letter-spacing: 0.08em;
+  font-size: 0.72rem;
-  color: var(--color-muted);
+  letter-spacing: 0.02em;
  color: var(--color-primary);
  margin-bottom: 6px;
  padding: 0 4px;
 }
@@ -720,38 +774,24 @@ onUnmounted(() => {
 .btn-new-note {
  flex: 1;
  padding: 7px 10px;
-  border-radius: 8px 0 0 8px;
+  border-radius: 8px;
-  border: 1px solid rgba(99, 102, 241, 0.4);
+  border: 1px solid rgba(124, 58, 237, 0.4);
-  border-right: none;
+  background: rgba(124, 58, 237, 0.12);
-  background: rgba(99, 102, 241, 0.12);
+  color: var(--color-primary, #a78bfa);
  color: var(--color-primary, #818cf8);
  cursor: pointer;
  font-size: 0.85rem;
  font-weight: 500;
  text-align: left;
  transition: background 0.15s;
 }
-.btn-new-note:hover { background: rgba(99, 102, 241, 0.2); }
+.btn-new-note:hover { background: rgba(124, 58, 237, 0.2); box-shadow: 0 0 12px rgba(124, 58, 237, 0.25); }
 .btn-new-chevron {
  padding: 7px 9px;
  border-radius: 0 8px 8px 0;
  border: 1px solid rgba(99, 102, 241, 0.4);
  background: rgba(99, 102, 241, 0.12);
  color: var(--color-primary, #818cf8);
  cursor: pointer;
  font-size: 0.78rem;
  line-height: 1;
  transition: background 0.15s, transform 0.15s;
 }
 .btn-new-chevron:hover { background: rgba(99, 102, 241, 0.2); }
 .btn-new-chevron.open { transform: scaleY(-1); }
 .new-note-menu {
  position: absolute;
  top: calc(100% + 4px);
  left: 0;
  right: 0;
  background: var(--color-bg-tertiary, #1a1b1e);
-  border: 1px solid rgba(99, 102, 241, 0.3);
+  border: 1px solid rgba(124, 58, 237, 0.3);
  border-radius: 8px;
  overflow: hidden;
  z-index: 50;
@@ -769,7 +809,7 @@ onUnmounted(() => {
  text-align: left;
  transition: background 0.12s;
 }
-.new-note-menu button:hover { background: rgba(99, 102, 241, 0.12); }
+.new-note-menu button:hover { background: rgba(124, 58, 237, 0.12); }
 .filter-btn {
  display: flex;
@@ -790,8 +830,8 @@ onUnmounted(() => {
 }
 .filter-btn:hover { background: rgba(255,255,255,0.05); opacity: 1; }
 .filter-btn.active {
-  background: rgba(99, 102, 241, 0.15);
+  background: rgba(124, 58, 237, 0.15);
-  color: var(--color-primary, #818cf8);
+  color: var(--color-primary, #a78bfa);
  opacity: 1;
 }
 .filter-btn-label { flex: 1; }
@@ -807,8 +847,8 @@ onUnmounted(() => {
  flex-shrink: 0;
 }
 .filter-btn.active .filter-count {
-  background: rgba(99, 102, 241, 0.2);
+  background: rgba(124, 58, 237, 0.2);
-  color: var(--color-primary, #818cf8);
+  color: var(--color-primary, #a78bfa);
 }
 .filter-tag { font-size: 0.78rem; }
@@ -853,7 +893,7 @@ onUnmounted(() => {
  outline: none;
  transition: border-color 0.15s;
 }
-.search-input:focus { border-color: var(--color-primary, #6366f1); }
+.search-input:focus { border-color: var(--color-primary, #7c3aed); }
 .sort-select {
  padding: 7px 10px;
  border-radius: 8px;
@@ -880,9 +920,9 @@ onUnmounted(() => {
 }
 .btn-graph:hover { color: var(--color-text); border-color: rgba(255,255,255,0.2); }
 .btn-graph.active {
-  background: rgba(99, 102, 241, 0.15);
+  background: rgba(124, 58, 237, 0.15);
-  border-color: rgba(99, 102, 241, 0.35);
+  border-color: rgba(124, 58, 237, 0.35);
-  color: var(--color-primary, #818cf8);
+  color: var(--color-primary, #a78bfa);
 }
 /* ── Card grid ───────────────────────────────────────────── */
@@ -890,6 +930,8 @@ onUnmounted(() => {
  flex: 1;
  overflow-y: auto;
  padding: 16px 20px;
  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);
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 12px;
@@ -911,16 +953,56 @@ onUnmounted(() => {
  overflow: hidden;
 }
 .k-card:hover {
-  border-color: rgba(255,255,255,0.14);
+  transform: translateY(-2px);
-  transform: translateY(-1px);
+  box-shadow: 0 8px 24px rgba(124, 58, 237, 0.15), 0 2px 8px rgba(0, 0, 0, 0.3);
-  box-shadow: 0 4px 16px rgba(0,0,0,0.2);
+  border-color: rgba(124, 58, 237, 0.2);
 }
-/* Type accent strip */
+/* Type-specific card DNA */
-.k-card--person { border-left: 3px solid #10b981; }
+.k-card--note   { border-color: rgba(124, 58, 237, 0.12); }
-.k-card--place  { border-left: 3px solid #f59e0b; }
+.k-card--task   { border-color: rgba(212, 160, 23, 0.10); }
-.k-card--list   { border-left: 3px solid #38bdf8; }
+.k-card--person { border-color: rgba(16, 185, 129, 0.10); }
-.k-card--note   { border-left: 3px solid #6366f1; }
+.k-card--place  { border-color: rgba(245, 158, 11, 0.10); }
 .k-card--list   { border-color: rgba(56, 189, 248, 0.10); }
 /* Top gradient bars */
 .k-card--note::before,
 .k-card--task::before,
 .k-card--list::before {
  content: '';
  position: absolute;
  top: 0;
  left: 0;
  height: 3px;
  border-radius: 14px 14px 0 0;
 }
 .k-card--note::before {
  right: 0;
  background: linear-gradient(90deg, #7c3aed, #a78bfa);
 }
 .k-card--task::before {
  width: 50%;
  background: linear-gradient(90deg, #d4a017, transparent);
 }
 .k-card--list::before {
  right: 0;
  background: linear-gradient(90deg, #38bdf8, #7dd3fc);
 }
 /* Corner accents for entity types */
 .k-card--person::after,
 .k-card--place::after {
  content: '';
  position: absolute;
  top: 0;
  right: 0;
  width: 60px;
  height: 60px;
  border-radius: 0 14px 0 60px;
  pointer-events: none;
 }
 .k-card--person::after { background: rgba(16, 185, 129, 0.06); }
 .k-card--place::after  { background: rgba(245, 158, 11, 0.06); }
 /* Type badge */
 .type-badge {
@@ -934,10 +1016,11 @@ onUnmounted(() => {
  text-transform: uppercase;
  letter-spacing: 0.04em;
 }
-.badge--note   { background: rgba(99,102,241,0.15); color: #818cf8; }
+.badge--note   { background: rgba(99,102,241,0.15); color: #a78bfa; }
 .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; }
 .k-card-body { flex: 1; padding-right: 40px; }
 .k-card-title {
@@ -1038,7 +1121,48 @@ onUnmounted(() => {
  background: rgba(255,255,255,0.05);
  color: var(--color-muted);
 }
-.k-card-date { font-size: 0.72rem; color: var(--color-muted); white-space: nowrap; }
+.k-card-date { font-size: 0.72rem; color: var(--color-accent-warm); white-space: nowrap; opacity: 0.7; }
 /* ── Task card ──────────────────────────────────────────── */
 .k-card-task {
  display: flex;
  flex-direction: column;
  gap: 6px;
 }
 .task-badges {
  display: flex;
  gap: 5px;
  flex-wrap: wrap;
 }
 .status-badge {
  font-size: 0.7rem;
  padding: 1px 7px;
  border-radius: 8px;
  font-weight: 600;
 }
 .status--todo { background: var(--color-status-todo-bg); color: var(--color-status-todo); }
 .status--in_progress { background: var(--color-status-in-progress-bg); color: var(--color-status-in-progress); }
 .status--done { background: var(--color-status-done-bg); color: var(--color-status-done); }
 .status--cancelled { background: var(--color-status-todo-bg); color: var(--color-status-todo); text-decoration: line-through; }
 .priority-badge {
  font-size: 0.7rem;
  padding: 1px 7px;
  border-radius: 8px;
  font-weight: 600;
 }
 .priority--low { background: var(--color-priority-low-bg); color: var(--color-priority-low); }
 .priority--normal { background: var(--color-priority-medium-bg); color: var(--color-priority-medium); }
 .priority--high { background: var(--color-priority-high-bg); color: var(--color-priority-high); }
 .task-due {
  font-size: 0.78rem;
  color: var(--color-accent-warm);
 }
 .task-overdue {
  color: var(--color-overdue);
  font-weight: 500;
 }
 /* ── Empty / loading ─────────────────────────────────────── */
 .knowledge-empty {
@@ -1053,6 +1177,13 @@ onUnmounted(() => {
  gap: 6px;
 }
 .empty-hint { font-size: 0.85rem; opacity: 0.7; }
 .empty-narrator {
  font-family: 'Fraunces', Georgia, serif;
  font-style: italic;
  font-size: 1rem;
  color: var(--color-accent-warm);
  opacity: 0.85;
 }
 /* ── Sentinel ────────────────────────────────────────────── */
 .scroll-sentinel {
@@ -1,376 +0,0 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, onUnmounted, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
 import { useNotesStore } from "@/stores/notes";
 import { useListKeyboardNavigation } from "@/composables/useListKeyboardNavigation";
 import SearchBar from "@/components/SearchBar.vue";
 import NoteCard from "@/components/NoteCard.vue";
 import TagPill from "@/components/TagPill.vue";
 import PaginationBar from "@/components/PaginationBar.vue";
 type ViewMode = "grid" | "list";
 const route = useRoute();
 const router = useRouter();
 const store = useNotesStore();
 const searchBarRef = ref<{ focus: () => void } | null>(null);
 function onFocusSearch() {
  searchBarRef.value?.focus();
 }
 const { activeIndex } = useListKeyboardNavigation(
  computed(() => store.notes),
  (note) => router.push(`/notes/${note.id}`),
 );
 const viewMode = ref<ViewMode>(
  (localStorage.getItem("fabled-notes-view-mode") as ViewMode) ?? "grid"
 );
 function setViewMode(mode: ViewMode) {
  viewMode.value = mode;
  localStorage.setItem("fabled-notes-view-mode", mode);
 }
 onMounted(() => {
  const tag = route.query.tag;
  if (tag) {
    const tags = Array.isArray(tag) ? (tag as string[]) : [tag as string];
    store.setTagFilters(tags);
  } else {
    store.refresh();
  }
  document.addEventListener("shortcut:focus-search", onFocusSearch);
 });
 onUnmounted(() => {
  document.removeEventListener("shortcut:focus-search", onFocusSearch);
 });
 watch(
  () => route.query.tag,
  (tag) => {
    if (tag) {
      const tags = Array.isArray(tag) ? (tag as string[]) : [tag as string];
      store.setTagFilters(tags);
    }
  }
 );
 function onSearch(q: string) {
  store.setSearch(q);
 }
 function onTagClick(tag: string) {
  store.addTagFilter(tag);
  router.replace({ query: { ...route.query, tag: store.activeTagFilters } });
 }
 function onTagDismiss(tag: string) {
  store.removeTagFilter(tag);
  const newQuery = { ...route.query };
  if (store.activeTagFilters.length > 0) {
    newQuery.tag = store.activeTagFilters;
  } else {
    delete newQuery.tag;
  }
  router.replace({ query: newQuery });
 }
 function onSortChange(e: Event) {
  const value = (e.target as HTMLSelectElement).value;
  store.setSort(value, store.sortOrder);
 }
 function toggleOrder() {
  store.setSort(store.sortField, store.sortOrder === "asc" ? "desc" : "asc");
 }
 function onOffsetUpdate(offset: number) {
  store.setOffset(offset);
 }
 </script>
 <template>
  <main class="notes-list">
    <div class="header">
      <h1>Notes</h1>
      <router-link to="/notes/new" class="btn-new">+ New Note</router-link>
    </div>
    <SearchBar ref="searchBarRef" @search="onSearch" />
    <div class="controls">
      <div class="sort-controls">
        <select :value="store.sortField" @change="onSortChange" class="sort-select">
          <option value="updated_at">Updated</option>
          <option value="created_at">Created</option>
          <option value="title">Title</option>
        </select>
        <button class="sort-order" @click="toggleOrder" :title="store.sortOrder === 'asc' ? 'Ascending' : 'Descending'">
          {{ store.sortOrder === "asc" ? "↑" : "↓" }}
        </button>
      </div>
      <!-- View mode toggle -->
      <div class="view-toggle">
        <button
          :class="['toggle-btn', { active: viewMode === 'grid' }]"
          title="Grid view"
          @click="setViewMode('grid')"
        >⊞</button>
        <button
          :class="['toggle-btn', { active: viewMode === 'list' }]"
          title="Compact list"
          @click="setViewMode('list')"
        >☰</button>
      </div>
    </div>
    <div v-if="store.activeTagFilters.length" class="active-filters">
      <span class="filter-label">Filtering by:</span>
      <TagPill
        v-for="tag in store.activeTagFilters"
        :key="tag"
        :tag="tag"
        dismissible
        @dismiss="onTagDismiss"
      />
      <button class="clear-filters" @click="store.clearTagFilters()">Clear all</button>
    </div>
    <div v-if="store.loading" class="note-list-skeleton">
      <div v-if="viewMode === 'grid'" class="skeleton-grid">
        <div class="skeleton-card" v-for="i in 6" :key="i"></div>
      </div>
      <div v-else class="skeleton-rows">
        <div class="skeleton-row" v-for="i in 8" :key="i"></div>
      </div>
    </div>
    <div v-else-if="store.notes.length === 0" class="empty-state">
      <template v-if="store.searchQuery || store.activeTagFilters.length">
        <p class="empty-title">No notes match your filters</p>
        <p class="empty-subtitle">Try adjusting your search or removing filters.</p>
      </template>
      <template v-else>
        <p class="empty-title">No notes yet</p>
        <p class="empty-subtitle">Create your first note to get started.</p>
        <router-link to="/notes/new" class="btn-cta">+ New Note</router-link>
      </template>
    </div>
    <!-- Grid view -->
    <div v-else-if="viewMode === 'grid'" class="cards-grid">
      <div
        v-for="(note, i) in store.notes"
        :key="note.id"
        :class="{ 'kb-active-item': activeIndex === i }"
      >
        <NoteCard :note="note" @tag-click="onTagClick" />
      </div>
    </div>
    <!-- Compact list view -->
    <div v-else class="cards-list">
      <div
        v-for="(note, i) in store.notes"
        :key="note.id"
        :class="{ 'kb-active-item': activeIndex === i }"
      >
        <NoteCard :note="note" compact @tag-click="onTagClick" />
      </div>
    </div>
    <PaginationBar
      :total="store.total"
      :limit="store.limit"
      :offset="store.offset"
      @update:offset="onOffsetUpdate"
    />
  </main>
 </template>
 <style scoped>
 .notes-list {
  max-width: var(--page-max-width);
  margin: 2rem auto;
  padding: 0 var(--page-padding-x);
  overflow-x: clip;
 }
 .header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 1rem;
 }
 .header h1 {
  margin: 0;
 }
 .btn-new {
  padding: 0.45rem 1rem;
  background: linear-gradient(135deg, #6366f1, #4f46e5);
  color: #fff;
  border-radius: var(--radius-sm);
  text-decoration: none;
  font-size: 0.9rem;
  box-shadow: 0 1px 6px rgba(99, 102, 241, 0.25);
 }
 .btn-new:hover {
  box-shadow: 0 3px 12px rgba(99, 102, 241, 0.45);
  filter: brightness(1.08);
 }
 .controls {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-top: 0.75rem;
 }
 .sort-controls {
  display: flex;
  align-items: center;
  gap: 0.25rem;
 }
 .sort-select {
  padding: 0.3rem 0.5rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text);
  font-size: 0.85rem;
 }
 .sort-order {
  padding: 0.3rem 0.5rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text);
  cursor: pointer;
  font-size: 0.95rem;
 }
 .view-toggle {
  display: flex;
  gap: 0.2rem;
 }
 .toggle-btn {
  padding: 0.3rem 0.55rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text-muted);
  cursor: pointer;
  font-size: 1rem;
  line-height: 1;
  transition: color 0.15s, border-color 0.15s, background 0.15s;
 }
 .toggle-btn.active {
  background: var(--color-primary);
  border-color: var(--color-primary);
  color: #fff;
 }
 .active-filters {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  margin-top: 0.75rem;
  flex-wrap: wrap;
 }
 .filter-label {
  font-size: 0.85rem;
  color: var(--color-text-secondary);
 }
 .clear-filters {
  background: none;
  border: none;
  color: var(--color-danger);
  cursor: pointer;
  font-size: 0.8rem;
  padding: 0;
 }
 /* Skeleton loading */
 .note-list-skeleton {
  margin-top: 1rem;
 }
 .skeleton-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
  gap: 0.75rem;
 }
 .skeleton-card {
  height: 140px;
  border-radius: var(--radius-md);
  background: linear-gradient(90deg, var(--color-bg-secondary) 25%, var(--color-border) 50%, var(--color-bg-secondary) 75%);
  background-size: 200% 100%;
  animation: skeleton-shimmer 1.4s ease infinite;
 }
 .skeleton-rows {
  display: flex;
  flex-direction: column;
  gap: 0.3rem;
 }
 .skeleton-row {
  height: 40px;
  border-radius: var(--radius-sm);
  background: linear-gradient(90deg, var(--color-bg-secondary) 25%, var(--color-border) 50%, var(--color-bg-secondary) 75%);
  background-size: 200% 100%;
  animation: skeleton-shimmer 1.4s ease infinite;
 }
@keyframes skeleton-shimmer {
  0% { background-position: 200% 0; }
  100% { background-position: -200% 0; }
 }
 /* Grid layout */
 .cards-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
  gap: 0.75rem;
  margin-top: 1rem;
 }
 .cards-grid > * {
  min-width: 0;
 }
 /* Compact list layout */
 .cards-list {
  display: flex;
  flex-direction: column;
  gap: 0.3rem;
  margin-top: 1rem;
 }
 .empty-state {
  text-align: center;
  margin-top: 3rem;
 }
 .empty-title {
  font-size: 1.1rem;
  font-weight: 600;
  margin: 0 0 0.25rem;
  color: var(--color-text);
 }
 .empty-subtitle {
  color: var(--color-text-muted);
  margin: 0 0 1rem;
  font-size: 0.95rem;
 }
 .btn-cta {
  display: inline-block;
  padding: 0.45rem 1rem;
  background: linear-gradient(135deg, #6366f1, #4f46e5);
  color: #fff;
  border-radius: var(--radius-sm);
  text-decoration: none;
  font-size: 0.9rem;
  box-shadow: 0 1px 6px rgba(99, 102, 241, 0.25);
 }
 .btn-cta:hover {
  box-shadow: 0 3px 12px rgba(99, 102, 241, 0.45);
  filter: brightness(1.08);
 }
 .kb-active-item {
  outline: 2px solid var(--color-primary);
  border-radius: var(--radius-md);
 }
 </style>
@@ -428,6 +428,28 @@ const notifySecurityAlerts = ref(true);
 const savingNotifications = ref(false);
 const notificationsSaved = ref(false);
 // VAPID key reset (admin)
 const vapidResetting = ref(false);
 const vapidResetMsg = ref("");
 const vapidResetError = ref(false);
 async function resetVapidKeys() {
  if (!confirm("This will regenerate VAPID keys and clear all push subscriptions. You will need to re-enable notifications afterwards. Continue?")) return;
  vapidResetting.value = true;
  vapidResetMsg.value = "";
  vapidResetError.value = false;
  try {
    await apiPost("/api/push/reset-vapid", {});
    vapidResetMsg.value = "Keys regenerated. Please re-enable notifications in this browser.";
    pushStore.checkSubscription();
  } catch {
    vapidResetError.value = true;
    vapidResetMsg.value = "Reset failed — check server logs.";
  } finally {
    vapidResetting.value = false;
  }
 }
 // CalDAV settings (per-user)
 const caldav = ref({
  caldav_url: "",
@@ -478,6 +500,8 @@ async function saveAdminVoice() {
    adminVoiceSaved.value = true;
    setTimeout(() => { adminVoiceSaved.value = false; }, 2000);
    voiceTabLoaded.value = false;
    // Always update global voice state so mic buttons appear/disappear immediately
    await store.checkVoiceStatus();
    if (adminVoiceEnabled.value) {
      await reloadVoiceModels();
    }
@@ -1882,6 +1906,22 @@ function formatUserDate(iso: string): string {
            Notifications are blocked. Allow them in your browser site settings to re-enable.
          </p>
        </template>
        <template v-if="authStore.isAdmin">
          <div class="field-divider" style="margin: 1rem 0;" />
          <p class="section-desc">
            If push notifications fail due to a corrupted or misformatted VAPID key, regenerate
            the key pair here. All existing subscriptions will be cleared — you will need to
            re-enable notifications in this browser afterwards.
          </p>
          <div class="actions" style="margin-top: 0.5rem;">
            <button class="btn-danger" :disabled="vapidResetting" @click="resetVapidKeys">
              {{ vapidResetting ? 'Regenerating…' : 'Regenerate VAPID Keys' }}
            </button>
          </div>
          <p v-if="vapidResetMsg" :class="vapidResetError ? 'field-error' : 'field-hint'" style="margin-top: 0.5rem;">
            {{ vapidResetMsg }}
          </p>
        </template>
      </section>
      <section class="settings-section">
@@ -1,678 +0,0 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, onUnmounted, watch } from "vue";
 import { useRoute, useRouter } from "vue-router";
 import { useTasksStore } from "@/stores/tasks";
 import type { Task, TaskStatus, TaskPriority } from "@/types/task";
 import { apiGet } from "@/api/client";
 import { useListKeyboardNavigation } from "@/composables/useListKeyboardNavigation";
 import SearchBar from "@/components/SearchBar.vue";
 import TaskCard from "@/components/TaskCard.vue";
 import TagPill from "@/components/TagPill.vue";
 type ViewMode = "smart" | "grouped";
 const route = useRoute();
 const router = useRouter();
 const store = useTasksStore();
 const searchBarRef = ref<{ focus: () => void } | null>(null);
 function onFocusSearch() {
  searchBarRef.value?.focus();
 }
 const _storedMode = localStorage.getItem("fabled-tasks-view-mode");
 const viewMode = ref<ViewMode>(_storedMode === "grouped" ? "grouped" : "smart");
 function setViewMode(mode: ViewMode) {
  viewMode.value = mode;
  localStorage.setItem("fabled-tasks-view-mode", mode);
  store.limit = mode === "grouped" ? 100 : 200;
  store.offset = 0;
  store.refresh();
 }
 // Keyboard nav disabled — smart sections span multiple containers
 useListKeyboardNavigation(
  computed(() => store.tasks),
  (task) => router.push(`/tasks/${task.id}`),
  ".kb-active-item",
  computed(() => false),
 );
 // Project map for group labels and task breadcrumbs
 const projectMap = ref<Map<number, string>>(new Map());
 async function loadProjects() {
  try {
    const data = await apiGet<{ projects: { id: number; title: string }[] }>("/api/projects");
    projectMap.value = new Map(data.projects.map((p) => [p.id, p.title]));
  } catch {
    // non-fatal — labels just won't show
  }
 }
 // Grouped tasks: [{projectId, title, tasks[]}]
 interface TaskGroup {
  projectId: number | null;
  title: string;
  tasks: Task[];
 }
 interface TaskSection {
  key: string;
  label: string;
  tasks: Task[];
 }
 const smartSections = computed<TaskSection[]>(() => {
  if (viewMode.value !== "smart") return [];
  const today = new Date().toISOString().slice(0, 10);
  const weekEnd = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
  const overdue: Task[] = [], dueToday: Task[] = [], thisWeek: Task[] = [],
        upcoming: Task[] = [], noDueDate: Task[] = [], done: Task[] = [];
  for (const task of store.tasks) {
    if (task.status === "done")   { done.push(task); continue; }
    if (!task.due_date)           { noDueDate.push(task); continue; }
    if (task.due_date < today)    { overdue.push(task); continue; }
    if (task.due_date === today)  { dueToday.push(task); continue; }
    if (task.due_date <= weekEnd) { thisWeek.push(task); continue; }
    upcoming.push(task);
  }
  const sections: TaskSection[] = [];
  if (overdue.length)   sections.push({ key: "overdue",  label: "Overdue",      tasks: overdue });
  if (dueToday.length)  sections.push({ key: "today",    label: "Due Today",    tasks: dueToday });
  if (thisWeek.length)  sections.push({ key: "week",     label: "This Week",    tasks: thisWeek });
  if (upcoming.length)  sections.push({ key: "upcoming", label: "Upcoming",     tasks: upcoming });
  if (noDueDate.length) sections.push({ key: "no-date",  label: "No Due Date",  tasks: noDueDate });
  if (done.length)      sections.push({ key: "done",     label: "Completed",    tasks: done });
  return sections;
 });
 const groupedTasks = computed<TaskGroup[]>(() => {
  if (viewMode.value !== "grouped") return [];
  const map = new Map<number | null, Task[]>();
  for (const task of store.tasks) {
    const key = task.project_id ?? null;
    if (!map.has(key)) map.set(key, []);
    map.get(key)!.push(task);
  }
  const groups: TaskGroup[] = [];
  // Named projects first (sorted by title), then "No Project"
  for (const [id, tasks] of map) {
    if (id !== null) {
      groups.push({
        projectId: id,
        title: projectMap.value.get(id) ?? `Project #${id}`,
        tasks,
      });
    }
  }
  groups.sort((a, b) => a.title.localeCompare(b.title));
  if (map.has(null)) {
    groups.push({ projectId: null, title: "No Project", tasks: map.get(null)! });
  }
  return groups;
 });
 onMounted(async () => {
  const tag = route.query.tag;
  if (tag) {
    const tags = Array.isArray(tag) ? (tag as string[]) : [tag as string];
    store.activeTagFilters = tags;
  }
  if (route.query.status) {
    const qs = route.query.status;
    store.statusFilter = (Array.isArray(qs) ? qs : [qs]).filter(Boolean) as TaskStatus[];
  }
  store.limit = viewMode.value === "grouped" ? 100 : 200;
  collapsedGroups.value.add("done");
  await Promise.all([store.refresh(), loadProjects()]);
  document.addEventListener("shortcut:focus-search", onFocusSearch);
 });
 onUnmounted(() => {
  document.removeEventListener("shortcut:focus-search", onFocusSearch);
 });
 watch(
  () => route.query.tag,
  (tag) => {
    if (tag) {
      const tags = Array.isArray(tag) ? (tag as string[]) : [tag as string];
      store.activeTagFilters = tags;
      store.offset = 0;
      store.refresh();
    }
  }
 );
 function onSearch(q: string) {
  store.setSearch(q);
 }
 function toggleStatusChip(value: TaskStatus) {
  const current = [...store.statusFilter];
  const idx = current.indexOf(value);
  if (idx === -1) current.push(value);
  else current.splice(idx, 1);
  store.setStatusFilter(current);
 }
 function togglePriorityChip(value: TaskPriority) {
  const current = [...store.priorityFilter];
  const idx = current.indexOf(value);
  if (idx === -1) current.push(value);
  else current.splice(idx, 1);
  store.setPriorityFilter(current);
 }
 function onTagClick(tag: string) {
  store.addTagFilter(tag);
  router.replace({ query: { ...route.query, tag: store.activeTagFilters } });
 }
 function onTagDismiss(tag: string) {
  store.removeTagFilter(tag);
  const newQuery = { ...route.query };
  if (store.activeTagFilters.length > 0) {
    newQuery.tag = store.activeTagFilters;
  } else {
    delete newQuery.tag;
  }
  router.replace({ query: newQuery });
 }
 function onSortChange(e: Event) {
  const value = (e.target as HTMLSelectElement).value;
  store.setSort(value, store.sortOrder);
 }
 function toggleOrder() {
  store.setSort(store.sortField, store.sortOrder === "asc" ? "desc" : "asc");
 }
 function onStatusToggle(id: number, status: TaskStatus) {
  store.patchStatus(id, status);
 }
 // Collapse state for grouped sections
 const collapsedGroups = ref<Set<string>>(new Set());
 function toggleGroup(key: string) {
  if (collapsedGroups.value.has(key)) {
    collapsedGroups.value.delete(key);
  } else {
    collapsedGroups.value.add(key);
  }
 }
 </script>
 <template>
  <main class="tasks-list">
    <div class="header">
      <h1>Tasks</h1>
      <router-link to="/tasks/new" class="btn-new">+ New Task</router-link>
    </div>
    <SearchBar ref="searchBarRef" @search="onSearch" />
    <div class="controls">
      <div class="filter-controls">
        <div class="filter-chip-group">
          <button v-for="s in (['todo', 'in_progress', 'done', 'cancelled'] as TaskStatus[])" :key="s"
            :class="['filter-chip', { active: store.statusFilter.includes(s) }]"
            @click="toggleStatusChip(s)">
            {{ { todo: 'Todo', in_progress: 'In Progress', done: 'Done', cancelled: 'Cancelled' }[s] }}
          </button>
        </div>
        <div class="filter-chip-group">
          <button v-for="p in (['low', 'medium', 'high'] as TaskPriority[])" :key="p"
            :class="['filter-chip', { active: store.priorityFilter.includes(p) }]"
            @click="togglePriorityChip(p)">
            {{ p.charAt(0).toUpperCase() + p.slice(1) }}
          </button>
        </div>
      </div>
      <div class="right-controls">
        <div class="sort-controls">
          <select :value="store.sortField" @change="onSortChange" class="sort-select">
            <option value="updated_at">Updated</option>
            <option value="created_at">Created</option>
            <option value="title">Title</option>
            <option value="due_date">Due Date</option>
            <option value="priority">Priority</option>
          </select>
          <button class="sort-order" @click="toggleOrder" :title="store.sortOrder === 'asc' ? 'Ascending' : 'Descending'">
            {{ store.sortOrder === "asc" ? "↑" : "↓" }}
          </button>
        </div>
        <!-- View mode toggle -->
        <div class="view-toggle">
          <button
            :class="['toggle-btn', { active: viewMode === 'smart' }]"
            title="Smart sections (by due date)"
            @click="setViewMode('smart')"
          >☰</button>
          <button
            :class="['toggle-btn', { active: viewMode === 'grouped' }]"
            title="Group by project"
            @click="setViewMode('grouped')"
          >⊟</button>
        </div>
      </div>
    </div>
    <div v-if="store.activeTagFilters.length" class="active-filters">
      <span class="filter-label">Filtering by:</span>
      <TagPill
        v-for="tag in store.activeTagFilters"
        :key="tag"
        :tag="tag"
        dismissible
        @dismiss="onTagDismiss"
      />
      <button class="clear-filters" @click="store.clearTagFilters()">Clear all</button>
    </div>
    <div v-if="store.loading" class="task-list-skeleton">
      <div class="skeleton-row" v-for="i in 6" :key="i"></div>
    </div>
    <div v-else-if="store.tasks.length === 0" class="empty-state">
      <template v-if="store.searchQuery || store.activeTagFilters.length || store.statusFilter.length || store.priorityFilter.length">
        <p class="empty-title">No tasks match your filters</p>
        <p class="empty-subtitle">Try adjusting your search or removing filters.</p>
      </template>
      <template v-else>
        <div class="empty-state-rich">
          <div class="empty-icon">✓</div>
          <p class="empty-title">No tasks yet</p>
          <p class="empty-sub">Create your first task to start tracking work</p>
          <router-link to="/tasks/new" class="empty-action">New task →</router-link>
        </div>
      </template>
    </div>
    <!-- Grouped view -->
    <template v-else-if="viewMode === 'grouped'">
      <div
        v-for="group in groupedTasks"
        :key="group.projectId ?? 'none'"
        class="task-group"
      >
        <button
          class="group-header"
          @click="toggleGroup(String(group.projectId))"
        >
          <span class="group-chevron">{{ collapsedGroups.has(String(group.projectId)) ? '▶' : '▼' }}</span>
          <span class="group-title">{{ group.title }}</span>
          <span class="group-count">{{ group.tasks.length }}</span>
          <router-link
            v-if="group.projectId"
            :to="`/projects/${group.projectId}`"
            class="group-open-link"
            @click.stop
          >Open project →</router-link>
        </button>
        <div v-if="!collapsedGroups.has(String(group.projectId))" class="group-tasks">
          <TaskCard
            v-for="task in group.tasks"
            :key="task.id"
            :task="task"
            compact
            @tag-click="onTagClick"
            @status-toggle="onStatusToggle"
          />
        </div>
      </div>
    </template>
    <!-- Smart sections view (by due date) -->
    <template v-else>
      <div v-for="section in smartSections" :key="section.key" class="task-section">
        <button class="section-header" @click="toggleGroup(section.key)">
          <span :class="['section-dot', `dot-${section.key}`]"></span>
          <span class="section-label">{{ section.label }}</span>
          <span class="section-count">{{ section.tasks.length }}</span>
          <span class="section-chevron">{{ collapsedGroups.has(section.key) ? "▶" : "▼" }}</span>
        </button>
        <div v-show="!collapsedGroups.has(section.key)" class="section-tasks">
          <TaskCard
            v-for="task in section.tasks"
            :key="task.id"
            :task="task"
            compact
            :project-title="task.project_id ? (projectMap.get(task.project_id) ?? undefined) : undefined"
            @tag-click="onTagClick"
            @status-toggle="onStatusToggle"
          />
        </div>
      </div>
    </template>
  </main>
 </template>
 <style scoped>
 .tasks-list {
  max-width: var(--page-max-width);
  margin: 2rem auto;
  padding: 0 var(--page-padding-x);
  overflow-x: clip;
 }
 .header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 1rem;
 }
 .header h1 {
  margin: 0;
 }
 .btn-new {
  padding: 0.45rem 1rem;
  background: linear-gradient(135deg, #6366f1, #4f46e5);
  color: #fff;
  border-radius: var(--radius-sm);
  text-decoration: none;
  font-size: 0.9rem;
  box-shadow: 0 1px 6px rgba(99, 102, 241, 0.25);
 }
 .btn-new:hover {
  box-shadow: 0 3px 12px rgba(99, 102, 241, 0.45);
  filter: brightness(1.08);
 }
 .controls {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-top: 0.75rem;
  gap: 0.5rem;
  flex-wrap: wrap;
 }
 .filter-controls {
  display: flex;
  flex-wrap: wrap;
  gap: 0.5rem;
 }
 .filter-chip-group {
  display: flex;
  flex-wrap: wrap;
  gap: 4px;
 }
 .filter-chip {
  padding: 3px 10px;
  border-radius: 999px;
  border: 1px solid var(--color-input-border);
  background: transparent;
  color: var(--color-text-muted);
  cursor: pointer;
  font-size: 0.78rem;
  transition: background 0.15s, color 0.15s, border-color 0.15s;
 }
 .filter-chip.active {
  background: var(--color-primary);
  color: #fff;
  border-color: var(--color-primary);
 }
 .right-controls {
  display: flex;
  align-items: center;
  gap: 0.5rem;
 }
 .filter-select,
 .sort-select {
  padding: 0.3rem 0.5rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text);
  font-size: 0.85rem;
 }
 .sort-controls {
  display: flex;
  align-items: center;
  gap: 0.25rem;
 }
 .sort-order {
  padding: 0.3rem 0.5rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text);
  cursor: pointer;
  font-size: 0.95rem;
 }
 .view-toggle {
  display: flex;
  gap: 0.2rem;
 }
 .toggle-btn {
  padding: 0.3rem 0.55rem;
  border: 1px solid var(--color-input-border);
  border-radius: var(--radius-sm);
  background: var(--color-bg-card);
  color: var(--color-text-muted);
  cursor: pointer;
  font-size: 1rem;
  line-height: 1;
  transition: color 0.15s, border-color 0.15s, background 0.15s;
 }
 .toggle-btn.active {
  background: var(--color-primary);
  border-color: var(--color-primary);
  color: #fff;
 }
 .active-filters {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  margin-top: 0.75rem;
  flex-wrap: wrap;
 }
 .filter-label {
  font-size: 0.85rem;
  color: var(--color-text-secondary);
 }
 .clear-filters {
  background: none;
  border: none;
  color: var(--color-danger);
  cursor: pointer;
  font-size: 0.8rem;
  padding: 0;
 }
 /* Skeleton loading */
 .task-list-skeleton {
  margin-top: 1rem;
 }
 .skeleton-row {
  height: 44px;
  border-radius: var(--radius-sm);
  background: linear-gradient(90deg, var(--color-bg-secondary) 25%, var(--color-border) 50%, var(--color-bg-secondary) 75%);
  background-size: 200% 100%;
  animation: skeleton-shimmer 1.4s ease infinite;
  margin-bottom: 0.3rem;
 }
@keyframes skeleton-shimmer {
  0% { background-position: 200% 0; }
  100% { background-position: -200% 0; }
 }
 /* Smart sections */
 .task-section {
  margin-top: 1rem;
 }
 .section-header {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  width: 100%;
  background: none;
  border: none;
  border-bottom: 1px solid var(--color-border);
  padding: 0.3rem 0;
  cursor: pointer;
  text-align: left;
  color: var(--color-text);
 }
 .section-header:hover .section-label {
  color: var(--color-primary);
 }
 .section-dot {
  width: 8px;
  height: 8px;
  border-radius: 50%;
  flex-shrink: 0;
 }
 .dot-overdue  { background: var(--color-danger, #e74c3c); }
 .dot-today    { background: var(--color-primary); }
 .dot-week     { background: #f59e0b; }
 .dot-upcoming { background: var(--color-text-secondary); }
 .dot-no-date  { background: var(--color-text-muted); }
 .dot-done     { background: var(--color-status-done, #22c55e); }
 .section-label {
  font-size: 0.8rem;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 0.06em;
  flex: 1;
  transition: color 0.15s;
 }
 .section-count {
  font-size: 0.75rem;
  color: var(--color-text-muted);
  background: var(--color-bg-secondary);
  border-radius: 999px;
  padding: 0.1rem 0.45rem;
 }
 .section-chevron {
  font-size: 0.65rem;
  color: var(--color-text-muted);
  flex-shrink: 0;
 }
 .section-tasks {
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
  padding: 0.5rem 0 0.25rem;
 }
 /* Grouped view */
 .task-group {
  margin-top: 1.25rem;
 }
 .group-header {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  width: 100%;
  background: none;
  border: none;
  border-bottom: 1px solid var(--color-border);
  padding: 0.3rem 0 0.3rem 0;
  cursor: pointer;
  text-align: left;
  color: var(--color-text);
 }
 .group-header:hover {
  color: var(--color-primary);
 }
 .group-chevron {
  font-size: 0.65rem;
  color: var(--color-text-muted);
  flex-shrink: 0;
 }
 .group-title {
  font-size: 0.8rem;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 0.06em;
  flex: 1;
 }
 .group-count {
  font-size: 0.75rem;
  color: var(--color-text-muted);
  background: var(--color-bg-secondary);
  border-radius: 999px;
  padding: 0.1rem 0.45rem;
 }
 .group-open-link {
  font-size: 0.75rem;
  color: var(--color-primary);
  text-decoration: none;
  flex-shrink: 0;
 }
 .group-open-link:hover {
  text-decoration: underline;
 }
 .group-tasks {
  display: flex;
  flex-direction: column;
  gap: 0.25rem;
  margin-top: 0.4rem;
 }
 .empty-state {
  text-align: center;
  margin-top: 3rem;
 }
 .empty-title {
  font-size: 1.1rem;
  font-weight: 600;
  margin: 0 0 0.25rem;
  color: var(--color-text);
 }
 .empty-subtitle {
  color: var(--color-text-muted);
  margin: 0 0 1rem;
  font-size: 0.95rem;
 }
 .btn-cta {
  display: inline-block;
  padding: 0.45rem 1rem;
  background: var(--color-primary);
  color: #fff;
  border-radius: var(--radius-sm);
  text-decoration: none;
  font-size: 0.9rem;
 }
 .empty-state-rich {
  text-align: center;
  padding: 3rem 1rem;
  color: var(--color-text-muted);
 }
 .empty-icon {
  font-size: 2.5rem;
  margin-bottom: 0.75rem;
  opacity: 0.3;
 }
 .empty-state-rich .empty-title {
  font-size: 1rem;
  font-weight: 600;
  color: var(--color-text-secondary);
  margin: 0 0 0.35rem;
 }
 .empty-sub {
  font-size: 0.85rem;
  margin: 0 0 1rem;
 }
 .empty-action {
  display: inline-block;
  padding: 0.4rem 1rem;
  border: 1px solid var(--color-primary);
  border-radius: var(--radius-sm);
  color: var(--color-primary);
  text-decoration: none;
  font-size: 0.85rem;
  transition: background 0.15s, color 0.15s;
 }
 .empty-action:hover {
  background: var(--color-primary);
  color: #fff;
 }
 .kb-active-item {
  outline: 2px solid var(--color-primary);
  border-radius: var(--radius-md);
 }
 </style>
@@ -27,7 +27,7 @@ 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:0.5b")
+    OLLAMA_BACKGROUND_MODEL: str = os.environ.get("OLLAMA_BACKGROUND_MODEL", "qwen2.5:3b")
    # 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.
@@ -453,7 +453,8 @@ async def discuss_article(item_id: int):
    if get_buffer(conv_id) is not None:
        return jsonify({"error": "Generation already in progress"}), 409
-    article_content = item.content or ""
+    from fabledassistant.services.rss import _fetch_full_article
    article_content = await _fetch_full_article(item.url) or item.content or ""
    # Store synthetic assistant message with read_article tool result
    synthetic_tool_calls = [{
@@ -533,8 +533,9 @@ async def create_conversation_from_article(item_id: int):
    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 = (item.content or "").strip()
+    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}"
@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 knowledge_bp = Blueprint("knowledge", __name__, url_prefix="/api/knowledge")
-_VALID_TYPES = {"note", "person", "place", "list"}
+_VALID_TYPES = {"note", "person", "place", "list", "task"}
 _VALID_SORTS = {"modified", "created", "alpha", "type"}
@@ -3,9 +3,9 @@ import logging
 from quart import Blueprint, jsonify, request
-from fabledassistant.auth import login_required, get_current_user_id
+from fabledassistant.auth import login_required, get_current_user_id, admin_required
 from fabledassistant.config import Config
-from fabledassistant.services.push import delete_subscription, save_subscription, vapid_enabled
+from fabledassistant.services.push import delete_subscription, regenerate_vapid_keys, save_subscription, vapid_enabled
 logger = logging.getLogger(__name__)
@@ -42,3 +42,13 @@ async def unsubscribe():
        return jsonify({"error": "endpoint is required"}), 400
    await delete_subscription(uid, endpoint)
    return "", 204
@push_bp.route("/reset-vapid", methods=["POST"])
@admin_required
 async def reset_vapid():
    """Regenerate VAPID keys and clear all push subscriptions."""
    ok = await regenerate_vapid_keys()
    if ok:
        return jsonify({"publicKey": Config.VAPID_PUBLIC_KEY}), 200
    return jsonify({"error": "Key regeneration failed"}), 500
@@ -80,10 +80,12 @@ async def transcribe_audio():
        return jsonify({"error": "Audio file too large (max 25 MB)"}), 413
    mime_type = audio_file.content_type or "audio/webm"
    form = await request.form
    context = (form.get("context") or "").strip() or None
    t0 = time.monotonic()
    try:
-        transcript = await transcribe(audio_bytes, mime_type)
+        transcript = await transcribe(audio_bytes, mime_type, initial_prompt=context)
    except Exception:
        logger.exception("STT transcription failed")
        return jsonify({"error": "Transcription failed"}), 500
@@ -117,7 +119,12 @@ async def synthesise_speech():
    if not text:
        return jsonify({"error": "text is required"}), 400
-    if len(text) > 8000:
+    char_count = len(text)
    if char_count > 8000:
        logger.warning(
            "TTS request rejected: text too long (%d chars, limit 8000). Preview: %r",
            char_count, text[:120],
        )
        return jsonify({"error": "text too long (max 8000 characters)"}), 400
    voice = str(data.get("voice", "af_heart"))
@@ -154,11 +161,29 @@ async def synthesise_speech():
        except Exception:
            pass
    blend_desc = f"blend({len(voice_blend)} voices)" if voice_blend else voice
    logger.info("TTS synthesis start: %d chars, voice=%s, speed=%.2f", char_count, blend_desc, speed)
    t0 = time.monotonic()
    try:
        wav_bytes = await synthesise(text, voice=voice, speed=speed, voice_blend=voice_blend)
    except Exception:
-        logger.exception("TTS synthesis failed")
+        logger.exception(
            "TTS synthesis failed: %d chars, voice=%s. Preview: %r",
            char_count, blend_desc, text[:120],
        )
        return jsonify({"error": "Synthesis failed"}), 500
    duration_ms = round((time.monotonic() - t0) * 1000)
    if not wav_bytes:
        logger.warning(
            "TTS synthesis returned empty audio: %d chars, voice=%s, %dms. Preview: %r",
            char_count, blend_desc, duration_ms, text[:120],
        )
    else:
        logger.info(
            "TTS synthesis complete: %d chars → %d bytes in %dms (voice=%s)",
            char_count, len(wav_bytes), duration_ms, blend_desc,
        )
    from quart import Response
    return Response(wav_bytes, mimetype="audio/wav")
@@ -118,31 +118,45 @@ _TOOL_LABELS: dict[str, str] = {
 async def _generate_title(messages: list[dict], user_id: int) -> str:
-    """Ask the LLM for a concise conversation title."""
+    """Ask the LLM for a concise conversation title.
-    # Build conversation text like summarize_conversation_as_note
+
-    conv_lines = []
+    Only uses user messages to avoid feeding tool-call JSON, system prompt
    fragments, or other noise into the title generator. Caps input length
    to keep the task fast and focused.
    """
    user_texts = []
    for m in messages:
-        if m["role"] == "system":
+        if m["role"] == "user":
-            continue
+            content = (m.get("content") or "").strip()
-        label = "User" if m["role"] == "user" else "Assistant"
+            if content:
-        conv_lines.append(f"{label}: {m['content']}")
+                user_texts.append(content[:300])
-    # Keep only last 6 pairs worth of text
+    if not user_texts:
-    conv_lines = conv_lines[-12:]
+        return ""
    # First + last user messages capture intent best
    if len(user_texts) > 2:
        user_texts = [user_texts[0], user_texts[-1]]
    prompt_messages = [
        {
-            "role": "system",
+            "role": "user",
            "content": (
-                "Generate a concise 3-8 word title for this conversation. "
+                "Generate a concise 3-8 word title for a conversation that started with:\n\n"
-                "Reply with ONLY the title, no quotes or punctuation."
+                + "\n\n".join(user_texts)
                + "\n\nReply with ONLY the title. No quotes, no punctuation, no explanation."
            ),
        },
        {"role": "user", "content": "\n\n".join(conv_lines)},
    ]
    bg_model = await get_setting(user_id, "background_model", Config.OLLAMA_BACKGROUND_MODEL)
-    title = await generate_completion(prompt_messages, bg_model, max_tokens=30)
+    title = await generate_completion(prompt_messages, bg_model, max_tokens=30, num_ctx=1024)
    # Strip common LLM noise: quotes, thinking tags, role labels
    title = title.strip().strip('"\'').strip()
-    return title[:100] if title else ""
+    for prefix in ("Title:", "title:", "Assistant:", "User:"):
        if title.startswith(prefix):
            title = title[len(prefix):].strip()
    # Drop anything after a newline (model sometimes adds explanation)
    if "\n" in title:
        title = title.split("\n")[0].strip()
    return title[:80] if title else ""
 async def _update_message(
@@ -46,6 +46,14 @@ def _note_to_item(note: Note) -> dict:
        item["item_count"] = len(list_items)
        item["checked_count"] = sum(1 for i in list_items if i["checked"])
        item["body"] = body
    # Task fields — override note_type and add status/priority/due_date
    if note.is_task:
        item["note_type"] = "task"
        item["status"] = note.status
        item["priority"] = note.priority
        item["due_date"] = note.due_date.isoformat() if note.due_date else None
    return item
@@ -69,17 +77,15 @@ async def query_knowledge(
        )
    async with async_session() as session:
-        base = (
+        base = select(Note).where(Note.user_id == user_id)
            select(Note)
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))  # exclude tasks
        )
-        if note_type:
+        if note_type == "task":
-            base = base.where(Note.note_type == note_type)
+            base = base.where(Note.status.isnot(None))
        elif note_type:
            base = base.where(Note.note_type == note_type).where(Note.status.is_(None))
        else:
-            # Exclude tasks — already done above; also exclude any legacy nulls
+            # All types including tasks
-            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
+            pass
        for tag in tags:
            base = base.where(Note.tags.contains([tag]))
@@ -115,12 +121,13 @@ async def _semantic_knowledge_search(
    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),
            threshold=0.3,
-            is_task=False,
+            is_task=is_task_filter,
        )
    except Exception:
        logger.warning("Semantic search unavailable, falling back to SQL", exc_info=True)
@@ -128,7 +135,9 @@ async def _semantic_knowledge_search(
    results = []
    for _score, note in candidates:
-        if note_type and note.entity_type != note_type:
+        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
@@ -145,12 +154,13 @@ async def get_knowledge_tags(user_id: int, note_type: str | None = None) -> list
        base = (
            select(func.unnest(Note.tags).label("tag"))
            .where(Note.user_id == user_id)
            .where(Note.status.is_(None))
        )
-        if note_type:
+        if note_type == "task":
-            base = base.where(Note.note_type == note_type)
+            base = base.where(Note.status.isnot(None))
        elif note_type:
            base = base.where(Note.note_type == note_type).where(Note.status.is_(None))
        else:
-            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
+            pass
        stmt = base.distinct().order_by("tag")
        rows = list((await session.execute(stmt)).scalars().all())
    return [r for r in rows if r]
@@ -159,6 +169,7 @@ async def get_knowledge_tags(user_id: int, note_type: str | None = None) -> list
 async def get_knowledge_counts(user_id: int, tags: list[str] | None = None) -> dict[str, int]:
    """Return per-type count of knowledge objects for the sidebar display."""
    async with async_session() as session:
        # Count non-task types
        stmt = (
            select(Note.note_type, func.count(Note.id))
            .where(Note.user_id == user_id)
@@ -170,11 +181,23 @@ async def get_knowledge_counts(user_id: int, tags: list[str] | None = None) -> d
            for tag in tags:
                stmt = stmt.where(Note.tags.contains([tag]))
        rows = list((await session.execute(stmt)).all())
-    counts = {row[0]: row[1] for row in rows}
+        counts = {row[0]: row[1] for row in rows}
-    # Ensure all types present even if zero
+
-    for t in ("note", "person", "place", "list"):
+        # Count tasks separately (is_task = status IS NOT NULL)
        task_stmt = (
            select(func.count(Note.id))
            .where(Note.user_id == user_id)
            .where(Note.status.isnot(None))
        )
        if tags:
            for tag in tags:
                task_stmt = task_stmt.where(Note.tags.contains([tag]))
        task_count: int = (await session.execute(task_stmt)).scalar_one()
        counts["task"] = task_count
    for t in ("note", "person", "place", "list", "task"):
        counts.setdefault(t, 0)
-    counts["total"] = sum(counts[t] for t in ("note", "person", "place", "list"))
+    counts["total"] = sum(counts[t] for t in ("note", "person", "place", "list", "task"))
    return counts
@@ -197,15 +220,14 @@ async def query_knowledge_ids(
        return [item["id"] for item in items], total
    async with async_session() as session:
-        base = (
+        base = select(Note.id).where(Note.user_id == user_id)
-            select(Note.id)
+
-            .where(Note.user_id == user_id)
+        if note_type == "task":
-            .where(Note.status.is_(None))
+            base = base.where(Note.status.isnot(None))
-        )
+        elif note_type:
-        if note_type:
+            base = base.where(Note.note_type == note_type).where(Note.status.is_(None))
            base = base.where(Note.note_type == note_type)
        else:
-            base = base.where(Note.note_type.in_(["note", "person", "place", "list"]))
+            pass
        for tag in tags:
            base = base.where(Note.tags.contains([tag]))
@@ -538,6 +538,11 @@ async def build_context(
        "Delete tools require an explicit user request. "
        "Never proactively search notes or comment on absent context."
    )
    tool_lines.append(
        "IMPORTANT: When creating tasks or notes, NEVER infer or guess a project name. "
        "Only set the project parameter if the user explicitly names a project. "
        "If the user says 'create a task to buy milk', do NOT assign it to a project."
    )
    tool_guidance = "\n".join(tool_lines)
    static_block = (
@@ -607,6 +612,25 @@ async def build_context(
            f"\n\n--- Earlier Conversation ---\n{history_summary}\n--- End Earlier Conversation ---"
        )
    # Detect briefing conversation — used for both system prompt instruction and article injection
    _is_briefing_conv = False
    if conv_id is not None:
        from fabledassistant.models import async_session as _async_session
        from fabledassistant.models.conversation import Conversation as _Conversation
        async with _async_session() as _sess:
            _conv = await _sess.get(_Conversation, conv_id)
        if _conv and getattr(_conv, "conversation_type", None) == "briefing":
            _is_briefing_conv = True
    if _is_briefing_conv:
        system_content += (
            "\n\nYou are in a briefing conversation. "
            "The conversation history contains today's briefing — news stories, weather, and tasks. "
            "When the user asks about a topic, person, or event from the briefing, answer directly "
            "from the conversation history and the article context that follows. "
            "Do NOT search the web for information that is already present in the briefing."
        )
    context_meta: dict = {
        "context_note_id": None,
        "context_note_title": None,
@@ -769,16 +793,10 @@ async def build_context(
            )
    # Briefing article context for follow-up Q&A
-    if conv_id is not None:
+    if _is_briefing_conv:
-        from fabledassistant.models import async_session as _async_session
+        article_context = await _build_briefing_article_context(conv_id)  # type: ignore[arg-type]
-        from fabledassistant.models.conversation import Conversation
+        if article_context:
-
+            user_context_parts.append(article_context.strip())
        async with _async_session() as _sess:
            _conv = await _sess.get(Conversation, conv_id)
        if _conv and getattr(_conv, "conversation_type", None) == "briefing":
            article_context = await _build_briefing_article_context(conv_id)
            if article_context:
                user_context_parts.append(article_context.strip())
    # Build final user message — context prefix (if any) followed by the actual message
    if user_context_parts:
@@ -124,7 +124,7 @@ async def generate_project_summary(user_id: int, project_id: int) -> None:
        from fabledassistant.services.settings import get_setting
        messages = [{"role": "user", "content": prompt}]
        bg_model = await get_setting(user_id, "background_model", Config.OLLAMA_BACKGROUND_MODEL)
-        summary = await generate_completion(messages, model=bg_model, max_tokens=400)
+        summary = await generate_completion(messages, model=bg_model, max_tokens=400, num_ctx=2048)
        if not summary:
            return
@@ -62,11 +62,14 @@ def ensure_vapid_keys() -> None:
        v = Vapid01()
        v.generate_keys()
-        private_pem = v.private_key.private_bytes(
+        # pywebpush expects the private key as a base64url-encoded DER blob
-            serialization.Encoding.PEM,
+        # (passed to Vapid.from_string → from_der), NOT a PEM string.
        private_der = v.private_key.private_bytes(
            serialization.Encoding.DER,
            serialization.PrivateFormat.TraditionalOpenSSL,
            serialization.NoEncryption(),
-        ).decode()
+        )
        private_b64 = base64.urlsafe_b64encode(private_der).rstrip(b"=").decode()
        pub_bytes = v.public_key.public_bytes(
            serialization.Encoding.X962,
@@ -76,15 +79,40 @@ def ensure_vapid_keys() -> None:
        # Persist so they survive container restarts.
        _VAPID_KEYS_FILE.parent.mkdir(parents=True, exist_ok=True)
-        _VAPID_KEYS_FILE.write_text(json.dumps({"private_key": private_pem, "public_key": public_b64}))
+        _VAPID_KEYS_FILE.write_text(json.dumps({"private_key": private_b64, "public_key": public_b64}))
-        Config.VAPID_PRIVATE_KEY = private_pem
+        Config.VAPID_PRIVATE_KEY = private_b64
        Config.VAPID_PUBLIC_KEY = public_b64
        logger.info("Generated new VAPID keys and saved to %s", _VAPID_KEYS_FILE)
    except Exception:
        logger.warning("Failed to generate VAPID keys — push notifications will be unavailable", exc_info=True)
 async def regenerate_vapid_keys() -> bool:
    """Delete existing VAPID keys, clear all push subscriptions, and generate a fresh pair.
    All existing browser subscriptions are invalidated when keys rotate, so they
    must be cleared — users will need to re-enable notifications.
    """
    if _VAPID_KEYS_FILE.exists():
        _VAPID_KEYS_FILE.unlink()
    Config.VAPID_PRIVATE_KEY = ""
    Config.VAPID_PUBLIC_KEY = ""
    # Clear all push subscriptions — they are bound to the old public key.
    async with async_session() as session:
        await session.execute(delete(PushSubscription))
        await session.commit()
    ensure_vapid_keys()
    enabled = vapid_enabled()
    if enabled:
        logger.info("VAPID keys regenerated successfully")
    else:
        logger.error("VAPID key regeneration failed")
    return enabled
 async def save_subscription(user_id: int, subscription_json: dict, user_agent: str | None = None) -> PushSubscription:
    """Upsert a push subscription by endpoint."""
    endpoint = subscription_json.get("endpoint", "")
@@ -21,6 +21,106 @@ MAX_SYNTHESIS_SOURCES = 12  # deduplicated sources passed to synthesis LLM
 CHARS_PER_SOURCE = 2000     # content chars per source sent to synthesis
 def _build_sources_block(sources: list[dict]) -> str:
    """Format fetched sources into a text block for LLM prompts."""
    parts = []
    for i, s in enumerate(sources, 1):
        content = (s.get("content") or s.get("snippet") or "")[:CHARS_PER_SOURCE]
        parts.append(
            f"[Source {i}] {s['title']}\nURL: {s['url']}\nSearch query: {s['query']}\n\n{content}"
        )
    return "\n\n" + ("─" * 60) + "\n\n".join(parts)
 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.
    """
    import json as _json
    sources_block = _build_sources_block(sources) if sources else "(no sources)"
    messages = [
        {
            "role": "system",
            "content": (
                "You are a research organizer. Given research sources on a topic, produce a JSON array "
                "of section objects that together cover the topic comprehensively from distinct angles.\n\n"
                "Rules:\n"
                "- Return exactly 3–7 sections\n"
                "- Each section must cover a unique angle — no overlap between sections\n"
                "- Titles must work as standalone note titles (specific, not generic like 'Overview')\n"
                "- focus: one sentence describing exactly what this section covers\n"
                "- Respond with ONLY a JSON array, no other text\n\n"
                'Example: [{"title": "CRISPR: Molecular Mechanisms", "focus": "How Cas9 identifies and cuts DNA at guide-RNA-specified sites"}]'
            ),
        },
        {
            "role": "user",
            "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)
    return []
 async def _synthesize_section(
    section_title: str,
    section_focus: str,
    sources: list[dict],
    model: str,
 ) -> tuple[str, str]:
    """Synthesize one focused note section.
    Returns (section_title, body_markdown). Does not stream.
    """
    sources_block = _build_sources_block(sources) if sources else "(no sources provided)"
    messages = [
        {
            "role": "system",
            "content": (
                "You are a focused research writer. Write a single well-structured note section "
                "on the specific topic provided.\n\n"
                "Requirements:\n"
                f"- Focus strictly on: {section_focus}\n"
                "- 300–600 words of substantive prose\n"
                "- Use ### for subsections only when they genuinely aid clarity\n"
                "- Do NOT include a top-level # heading — the title is set separately\n"
                "- Write in detailed prose paragraphs — not bullet points\n"
                "- End with a '## Sources' section listing relevant source URLs as markdown hyperlinks\n"
                "- Ignore source material that falls outside your assigned focus"
            ),
        },
        {
            "role": "user",
            "content": (
                f"Section title: {section_title}\n"
                f"Focus: {section_focus}\n\n"
                f"Sources:\n{sources_block}"
            ),
        },
    ]
    raw = await generate_completion(messages, model, max_tokens=2048, num_ctx=16384)
    return section_title, raw.strip()
 async def run_research_pipeline(
    topic: str,
    user_id: int,
@@ -28,14 +128,17 @@ async def run_research_pipeline(
    buf=None,
    project_id: int | None = None,
 ) -> Note:
-    """Full research pipeline: search → fetch → synthesize → create note.
+    """Full research pipeline: search → fetch → outline → section notes → index note.
-    Emits status events via buf.append_event throughout (when buf is provided).
+    Emits status events via buf throughout (when buf is provided).
-    Returns the created Note.
+    Returns the index note (or a single fallback note on outline failure).
    """
    def _status(msg: str) -> None:
        if buf is not None:
            buf.append_event("status", {"status": msg})
    # Step 1: Generate sub-queries
-    if buf is not None:
+    _status("Generating search queries...")
        buf.append_event("status", {"status": "Generating search queries..."})
    queries = await _generate_sub_queries(topic, model)
    logger.info("Research: generated %d sub-queries for topic '%s'", len(queries), topic)
@@ -43,8 +146,7 @@ async def run_research_pipeline(
    async def _search_with_stagger(i: int, query: str) -> tuple[str, list[dict]]:
        if i > 0:
            await asyncio.sleep(0.2 * i)
-        if buf is not None:
+        _status(f"Searching: {query}...")
            buf.append_event("status", {"status": f"Searching: {query}..."})
        results = await _search_searxng(query)
        logger.info("Research: query '%s' → %d results", query, len(results))
        return query, results
@@ -66,8 +168,7 @@ async def run_research_pipeline(
    # Fetch all unique URLs in parallel
    async def _fetch_source(url: str, result: dict, query: str) -> dict:
        title = result.get("title", url)
-        if buf is not None:
+        _status(f"Reading: {title[:60]}...")
            buf.append_event("status", {"status": f"Reading: {title[:60]}..."})
        content = await fetch_url_content(url)
        return {
            "url": url,
@@ -84,39 +185,97 @@ async def run_research_pipeline(
    if not all_sources:
        raise ValueError(f"No results found for '{topic}'")
-    # Step 3: Filter failed fetches
+    good_sources = [s for s in all_sources if not s["content"].startswith("[Failed to fetch")]
    good_sources = [
        s for s in all_sources
        if not s["content"].startswith("[Failed to fetch")
    ]
    if not good_sources:
        raise ValueError(f"Could not read any sources for '{topic}'")
    # Limit to top N sources for synthesis (already deduplicated by URL)
    synthesis_sources = good_sources[:MAX_SYNTHESIS_SOURCES]
    logger.info(
        "Research: %d/%d sources successfully fetched, using %d for synthesis",
        len(good_sources), len(all_sources), len(synthesis_sources),
    )
-    # Step 4: Synthesize (streams tokens into chat as the note is being written)
+    # Step 3: Generate topic outline
-    if buf is not None:
+    _status("Generating outline...")
-        buf.append_event("status", {"status": f"Synthesizing report from {len(synthesis_sources)} sources..."})
+    outline = await _generate_outline(topic, synthesis_sources, model)
    title, body = await _synthesize_note(topic, synthesis_sources, model, buf)
-    # Step 5: Create note
+    # Fallback: outline failed or too short → single monolithic note
-    if buf is not None:
+    if not outline:
-        buf.append_event("status", {"status": "Saving note..."})
+        logger.warning("Research outline empty, falling back to single note for '%s'", topic)
-    note = await create_note(
+        _status("Synthesizing report...")
        title, body = await _synthesize_note(topic, synthesis_sources, model, buf=None)
        note = await create_note(
            user_id=user_id, title=title, body=body, tags=["research"], project_id=project_id,
        )
        logger.info("Research (fallback): created note id=%d title='%s'", note.id, note.title)
        return note
    # Step 4: Synthesize each section in parallel
    for section in outline:
        _status(f"Writing: {section['title']}...")
    raw_results = await asyncio.gather(
        *[_synthesize_section(s["title"], s["focus"], synthesis_sources, model) for s in outline],
        return_exceptions=True,
    )
    # Step 5: Create section notes sequentially
    _status(f"Saving {len(outline)} notes...")
    section_note_pairs: list[tuple[dict, Note]] = []
    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)
    # All sections failed — fall back to single note
    if not section_note_pairs:
        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)
        note = await create_note(
            user_id=user_id, title=title, body=body, tags=["research"], project_id=project_id,
        )
        return note
    # Step 6: Create index note
    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",
        "",
    ]
    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.*"]
    index_note = await create_note(
        user_id=user_id,
-        title=title,
+        title=f"Research: {topic}",
-        body=body,
+        body="\n".join(index_lines),
-        tags=["research"],
+        tags=["research", "research-index"],
        project_id=project_id,
    )
-    logger.info("Research: created note id=%d title='%s'", note.id, note.title)
+    logger.info(
-    return note
+        "Research: created %d section notes + index id=%d for topic '%s'",
        len(section_note_pairs), index_note.id, topic,
    )
    return index_note
 async def _generate_sub_queries(topic: str, model: str) -> list[str]:
@@ -248,13 +407,7 @@ async def _synthesize_note(
    When buf is provided, tokens are streamed into the chat buffer in real time
    so the user can see the note being written. Uses an extended context window.
    """
-    sources_text_parts = []
+    sources_block = _build_sources_block(sources)
    for i, s in enumerate(sources, 1):
        content = (s.get("content") or s.get("snippet") or "")[:CHARS_PER_SOURCE]
        sources_text_parts.append(
            f"[Source {i}] {s['title']}\nURL: {s['url']}\nSearch query: {s['query']}\n\n{content}"
        )
    sources_block = "\n\n" + ("─" * 60) + "\n\n".join(sources_text_parts)
    messages = [
        {
@@ -55,8 +55,12 @@ def stt_available() -> bool:
    return _model is not None
-async def transcribe(audio_bytes: bytes, mime_type: str = "audio/webm") -> str:
+async def transcribe(audio_bytes: bytes, mime_type: str = "audio/webm", initial_prompt: str | None = None) -> str:
-    """Transcribe audio bytes to text. Runs the model in a thread executor."""
+    """Transcribe audio bytes to text. Runs the model in a thread executor.
    initial_prompt: optional text to bias the model toward domain-specific vocabulary
    (e.g. recent conversation context). Reduces mishearings like "gold" for "cold".
    """
    if _model is None:
        raise RuntimeError("STT model not loaded")
@@ -73,7 +77,11 @@ async def transcribe(audio_bytes: bytes, mime_type: str = "audio/webm") -> str:
            f.write(audio_bytes)
            f.flush()
            t0 = time.monotonic()
-            segments, _ = _model.transcribe(f.name, beam_size=5)  # type: ignore[union-attr]
+            segments, _ = _model.transcribe(  # type: ignore[union-attr]
                f.name,
                beam_size=5,
                initial_prompt=initial_prompt or None,
            )
            text = " ".join(seg.text.strip() for seg in segments).strip()
            logger.debug("STT transcription took %.2fs", time.monotonic() - t0)
            return text
@@ -101,7 +101,7 @@ _CORE_TOOLS = [
                    },
                    "project": {
                        "type": "string",
-                        "description": "Optional project name to assign this task to",
+                        "description": "Optional project name to assign this task to. Only set this if the user explicitly named a project. Do NOT infer a project from the task content or context.",
                    },
                    "parent_task": {
                        "type": "string",
@@ -147,7 +147,7 @@ _CORE_TOOLS = [
                    },
                    "project": {
                        "type": "string",
-                        "description": "Optional project name to assign this note to",
+                        "description": "Optional project name to assign this note to. Only set this if the user explicitly named a project. Do NOT infer a project from the note content or context.",
                    },
                    "confirmed": {
                        "type": "boolean",
@@ -258,8 +258,8 @@ _CORE_TOOLS = [
        "function": {
            "name": "get_note",
            "description": (
-                "Retrieve the full content of a specific note. Use this when the user asks to read, "
+                "Retrieve the full content of a specific note or task. Use this when the user asks to read, "
-                "view, or check what a particular note says. Returns the complete note body."
+                "view, or check what a particular note or task says. Returns the complete body."
            ),
            "parameters": {
                "type": "object",
@@ -316,7 +316,7 @@ _CORE_TOOLS = [
            "name": "delete_note",
            "description": (
                "Delete a note permanently. Use ONLY when the user explicitly asks to delete or remove a note. "
-                "This action requires user confirmation and cannot be undone."
+                "Always confirm with the user first — this cannot be undone."
            ),
            "parameters": {
                "type": "object",
@@ -325,6 +325,10 @@ _CORE_TOOLS = [
                        "type": "string",
                        "description": "Title or keyword to find the note to delete",
                    },
                    "confirmed": {
                        "type": "boolean",
                        "description": "Must be true — only set after the user has explicitly confirmed they want this note deleted.",
                    },
                },
                "required": ["query"],
            },
@@ -336,7 +340,7 @@ _CORE_TOOLS = [
            "name": "delete_task",
            "description": (
                "Delete a task permanently. Use ONLY when the user explicitly asks to delete or remove a task. "
-                "This action requires user confirmation and cannot be undone."
+                "Always confirm with the user first — this cannot be undone."
            ),
            "parameters": {
                "type": "object",
@@ -345,6 +349,10 @@ _CORE_TOOLS = [
                        "type": "string",
                        "description": "Title or keyword to find the task to delete",
                    },
                    "confirmed": {
                        "type": "boolean",
                        "description": "Must be true — only set after the user has explicitly confirmed they want this task deleted.",
                    },
                },
                "required": ["query"],
            },
@@ -937,6 +945,28 @@ _RAG_TOOLS = [
            },
        },
    },
    {
        "type": "function",
        "function": {
            "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": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "A valid Python math expression (e.g. '(450 * 1.13) / 12', 'sqrt(144)', 'log(1000, 10)')",
                    },
                },
                "required": ["expression"],
            },
        },
    },
 ]
 _ENTITY_TOOLS = [
@@ -964,6 +994,29 @@ _ENTITY_TOOLS = [
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "update_person",
            "description": (
                "Update details about a saved person. Use this when the user corrects or adds new "
                "information about someone already in the knowledge base."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Name or keyword to find the person"},
                    "relationship": {"type": "string", "description": "Updated relationship to the user"},
                    "phone": {"type": "string", "description": "Updated phone number"},
                    "email": {"type": "string", "description": "Updated email address"},
                    "birthday": {"type": "string", "description": "Updated birthday in YYYY-MM-DD format"},
                    "address": {"type": "string", "description": "Updated home or mailing address"},
                    "notes": {"type": "string", "description": "Updated free-form notes about this person"},
                },
                "required": ["query"],
            },
        },
    },
    {
        "type": "function",
        "function": {
@@ -987,6 +1040,28 @@ _ENTITY_TOOLS = [
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "update_place",
            "description": (
                "Update details about a saved place. Use this when the user corrects or adds new "
                "information about a location already in the knowledge base."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Name or keyword to find the place"},
                    "address": {"type": "string", "description": "Updated street address"},
                    "phone": {"type": "string", "description": "Updated phone number"},
                    "hours": {"type": "string", "description": "Updated opening hours"},
                    "url": {"type": "string", "description": "Updated website URL"},
                    "notes": {"type": "string", "description": "Updated free-form notes about this place"},
                },
                "required": ["query"],
            },
        },
    },
    {
        "type": "function",
        "function": {
@@ -1051,12 +1126,71 @@ _ENTITY_TOOLS = [
 ]
 _PROFILE_TOOLS = [
    {
        "type": "function",
        "function": {
            "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": {
                "type": "object",
                "properties": {},
            },
        },
    },
    {
        "type": "function",
        "function": {
            "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": {
                "type": "object",
                "properties": {
                    "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 get_tools_for_user(user_id: int) -> list[dict]:
    """Build the tool list for a user based on their configured integrations."""
    tools = list(_CORE_TOOLS)
    tools.extend(_URL_TOOLS)
    tools.extend(_RAG_TOOLS)
    tools.extend(_ENTITY_TOOLS)
    tools.extend(_PROFILE_TOOLS)
    if await is_caldav_configured(user_id):
        tools.extend(_CALDAV_TOOLS)
    if Config.searxng_enabled():
@@ -1698,6 +1832,12 @@ async def execute_tool(
                note = notes[0]
            if note.status is not None:
                return {"success": False, "error": f"'{note.title}' is a task. Use delete_task instead."}
            if not arguments.get("confirmed"):
                return {
                    "success": False,
                    "requires_confirmation": True,
                    "error": f"Deleting '{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 note."}
@@ -1717,6 +1857,12 @@ async def execute_tool(
                note = notes[0]
            if note.status is None:
                return {"success": False, "error": f"'{note.title}' is a note. Use delete_note instead."}
            if not arguments.get("confirmed"):
                return {
                    "success": False,
                    "requires_confirmation": True,
                    "error": f"Deleting '{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 task."}
@@ -2172,6 +2318,72 @@ async def execute_tool(
            _schedule_embedding(note.id, user_id, name, note.body)
            return {"success": True, "type": "place", "data": {"id": note.id, "name": name}}
        elif tool_name == "update_person":
            query = str(arguments.get("query", "")).strip()
            if not query:
                return {"success": False, "error": "query is required"}
            existing, _ = await list_notes(user_id=user_id, q=query, is_task=False, limit=10)
            target = next((n for n in existing if n.note_type == "person"), None)
            if target is None:
                return {"success": False, "error": f"No person found matching '{query}'. Use create_person to add them."}
            meta = dict(target.entity_meta or {})
            for field in ("relationship", "phone", "email", "birthday", "address"):
                val = arguments.get(field)
                if val is not None:
                    meta[field] = str(val)
            body_lines = []
            if meta.get("relationship"):
                body_lines.append(f"**Relationship:** {meta['relationship']}")
            if meta.get("phone"):
                body_lines.append(f"**Phone:** {meta['phone']}")
            if meta.get("email"):
                body_lines.append(f"**Email:** {meta['email']}")
            if meta.get("birthday"):
                body_lines.append(f"**Birthday:** {meta['birthday']}")
            if meta.get("address"):
                body_lines.append(f"**Address:** {meta['address']}")
            extra_notes = arguments.get("notes")
            if extra_notes is not None:
                body_lines.append(f"\n{extra_notes}")
            new_body = "\n".join(body_lines)
            updated = await update_note(user_id=user_id, note_id=target.id, body=new_body, entity_meta=meta)
            if updated is None:
                return {"success": False, "error": "Failed to update person."}
            _schedule_embedding(target.id, user_id, target.title, new_body)
            return {"success": True, "type": "person_updated", "data": {"id": target.id, "name": target.title}}
        elif tool_name == "update_place":
            query = str(arguments.get("query", "")).strip()
            if not query:
                return {"success": False, "error": "query is required"}
            existing, _ = await list_notes(user_id=user_id, q=query, is_task=False, limit=10)
            target = next((n for n in existing if n.note_type == "place"), None)
            if target is None:
                return {"success": False, "error": f"No place found matching '{query}'. Use create_place to add it."}
            meta = dict(target.entity_meta or {})
            for field in ("address", "phone", "hours", "url"):
                val = arguments.get(field)
                if val is not None:
                    meta[field] = str(val)
            body_lines = []
            if meta.get("address"):
                body_lines.append(f"**Address:** {meta['address']}")
            if meta.get("phone"):
                body_lines.append(f"**Phone:** {meta['phone']}")
            if meta.get("hours"):
                body_lines.append(f"**Hours:** {meta['hours']}")
            if meta.get("url"):
                body_lines.append(f"**Website:** {meta['url']}")
            extra_notes = arguments.get("notes")
            if extra_notes is not None:
                body_lines.append(f"\n{extra_notes}")
            new_body = "\n".join(body_lines)
            updated = await update_note(user_id=user_id, note_id=target.id, body=new_body, entity_meta=meta)
            if updated is None:
                return {"success": False, "error": "Failed to update place."}
            _schedule_embedding(target.id, user_id, target.title, new_body)
            return {"success": True, "type": "place_updated", "data": {"id": target.id, "name": target.title}}
        elif tool_name == "create_list":
            name = str(arguments.get("name", "")).strip()
            if not name:
@@ -2235,6 +2447,65 @@ async def execute_tool(
            _schedule_embedding(target.id, user_id, target.title, cleaned)
            return {"success": True, "type": "list_cleared", "data": {"id": target.id, "name": target.title}}
        elif tool_name == "get_profile":
            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 [],
                },
            }
        elif tool_name == "update_profile":
            from fabledassistant.services.user_profile import update_profile as _update_profile, VALID_EXPERTISE, VALID_STYLES, VALID_TONES
            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."}
            profile = await _update_profile(user_id, data)
            return {
                "success": True,
                "type": "profile_updated",
                "data": {"fields_updated": list(data.keys())},
            }
        elif tool_name == "calculate":
            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}}
        else:
            return {"success": False, "error": f"Unknown tool: {tool_name}"}
@@ -239,17 +239,32 @@ async def synthesise(
        voice_param = _build_voice_param()
        t0 = time.monotonic()
        audio_chunks: list = []
-        for _, _, audio in _pipeline(text, voice=voice_param, speed=speed):  # type: ignore[misc]
+        try:
-            if audio is not None:
+            for _, _, audio in _pipeline(text, voice=voice_param, speed=speed):  # type: ignore[misc]
-                audio_chunks.append(audio)
+                if audio is not None:
                    audio_chunks.append(audio)
        except Exception:
            logger.exception(
                "Kokoro pipeline error during synthesis: %d chars, preview=%r",
                len(text), text[:80],
            )
            raise
        if not audio_chunks:
            logger.warning(
                "Kokoro produced no audio chunks: %d chars, preview=%r",
                len(text), text[:80],
            )
            return b""
        combined = np.concatenate(audio_chunks)
        buf = io.BytesIO()
        sf.write(buf, combined, samplerate=24000, format="WAV", subtype="PCM_16")
-        logger.debug("TTS synthesis took %.2fs for %d chars", time.monotonic() - t0, len(text))
+        elapsed = time.monotonic() - t0
        logger.info(
            "Kokoro synthesis: %d chars → %d samples (%.2fs, %.0f chars/s)",
            len(text), len(combined), elapsed, len(text) / elapsed if elapsed > 0 else 0,
        )
        return buf.getvalue()
    loop = asyncio.get_running_loop()
@@ -0,0 +1,186 @@
 """Tests for the multi-note research pipeline."""
 import json
 import pytest
 from unittest.mock import AsyncMock, patch
@pytest.mark.asyncio
 async def test_generate_outline_parses_valid_json():
    """_generate_outline returns parsed sections when model returns valid JSON."""
    from fabledassistant.services.research import _generate_outline
    outline_json = json.dumps([
        {"title": "Section One", "focus": "Focus one"},
        {"title": "Section Two", "focus": "Focus two"},
        {"title": "Section Three", "focus": "Focus three"},
    ])
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value=outline_json):
        result = await _generate_outline("test topic", [], "test-model")
    assert len(result) == 3
    assert result[0]["title"] == "Section One"
    assert result[0]["focus"] == "Focus one"
@pytest.mark.asyncio
 async def test_generate_outline_returns_empty_on_parse_failure():
    """_generate_outline returns [] when model output is not parseable JSON."""
    from fabledassistant.services.research import _generate_outline
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value="not json at all"):
        result = await _generate_outline("test topic", [], "test-model")
    assert result == []
@pytest.mark.asyncio
 async def test_generate_outline_returns_empty_when_fewer_than_3_sections():
    """_generate_outline returns [] when model returns fewer than 3 valid sections."""
    from fabledassistant.services.research import _generate_outline
    outline_json = json.dumps([{"title": "Only One", "focus": "Focus"}])
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value=outline_json):
        result = await _generate_outline("test topic", [], "test-model")
    assert result == []
@pytest.mark.asyncio
 async def test_generate_outline_truncates_to_8():
    """_generate_outline truncates results to at most 8 sections."""
    from fabledassistant.services.research import _generate_outline
    sections = [{"title": f"Section {i}", "focus": f"Focus {i}"} for i in range(10)]
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value=json.dumps(sections)):
        result = await _generate_outline("test topic", [], "test-model")
    assert len(result) == 8
@pytest.mark.asyncio
 async def test_generate_outline_skips_malformed_entries():
    """_generate_outline filters out entries missing title or focus."""
    from fabledassistant.services.research import _generate_outline
    outline_json = json.dumps([
        {"title": "Good One", "focus": "Good focus"},
        {"title": "Missing focus"},
        {"focus": "Missing title"},
        {"title": "Good Two", "focus": "Good focus two"},
        {"title": "Good Three", "focus": "Good focus three"},
    ])
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value=outline_json):
        result = await _generate_outline("test topic", [], "test-model")
    assert len(result) == 3
    assert all(s["title"] and s["focus"] for s in result)
@pytest.mark.asyncio
 async def test_synthesize_section_returns_title_and_body():
    """_synthesize_section returns (section_title, body) from model output."""
    from fabledassistant.services.research import _synthesize_section
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value="The body of this section."):
        title, body = await _synthesize_section(
            section_title="Quantum Entanglement: Mechanisms",
            section_focus="How entanglement works at the particle level",
            sources=[],
            model="test-model",
        )
    assert title == "Quantum Entanglement: Mechanisms"
    assert body == "The body of this section."
@pytest.mark.asyncio
 async def test_synthesize_section_strips_whitespace():
    """_synthesize_section strips leading/trailing whitespace from body."""
    from fabledassistant.services.research import _synthesize_section
    with patch("fabledassistant.services.research.generate_completion", new_callable=AsyncMock, return_value="\n\n  body text  \n\n"):
        title, body = await _synthesize_section("Title", "Focus", [], "model")
    assert body == "body text"
@pytest.mark.asyncio
 async def test_pipeline_creates_section_notes_and_index():
    """run_research_pipeline creates N section notes + 1 index note, returns index."""
    from unittest.mock import MagicMock
    outline = [
        {"title": "Section A", "focus": "Focus A"},
        {"title": "Section B", "focus": "Focus B"},
        {"title": "Section C", "focus": "Focus C"},
    ]
    note_id_counter = iter(range(10, 20))
    def _make_note(user_id, title, body, tags, project_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.fetch_url_content", new_callable=AsyncMock, return_value="content"), \
         patch("fabledassistant.services.research._generate_outline", new_callable=AsyncMock, return_value=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.create_note", new_callable=AsyncMock, side_effect=_make_note):
        from fabledassistant.services.research import run_research_pipeline
        result = await run_research_pipeline("test topic", user_id=1, model="test-model")
    assert result.title == "Research: test topic"
@pytest.mark.asyncio
 async def test_pipeline_falls_back_to_single_note_when_outline_empty():
    """run_research_pipeline falls back to single-note synthesis when _generate_outline returns []."""
    from unittest.mock import MagicMock
    single_note = MagicMock()
    single_note.id = 99
    single_note.title = "Research: test topic"
    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.fetch_url_content", new_callable=AsyncMock, return_value="content"), \
         patch("fabledassistant.services.research._generate_outline", new_callable=AsyncMock, return_value=[]), \
         patch("fabledassistant.services.research._synthesize_note", new_callable=AsyncMock, return_value=("Research: test topic", "body")), \
         patch("fabledassistant.services.research.create_note", new_callable=AsyncMock, return_value=single_note):
        from fabledassistant.services.research import run_research_pipeline
        result = await run_research_pipeline("test topic", user_id=1, model="test-model")
    assert result.id == 99
@pytest.mark.asyncio
 async def test_pipeline_falls_back_when_all_sections_fail():
    """run_research_pipeline falls back to single note when all section syntheses raise."""
    from unittest.mock import MagicMock
    outline = [
        {"title": "Section A", "focus": "Focus A"},
        {"title": "Section B", "focus": "Focus B"},
        {"title": "Section C", "focus": "Focus C"},
    ]
    fallback_note = MagicMock()
    fallback_note.id = 77
    fallback_note.title = "Research: test topic"
    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.fetch_url_content", new_callable=AsyncMock, return_value="content"), \
         patch("fabledassistant.services.research._generate_outline", new_callable=AsyncMock, return_value=outline), \
         patch("fabledassistant.services.research._synthesize_section", new_callable=AsyncMock, side_effect=RuntimeError("synthesis failed")), \
         patch("fabledassistant.services.research._synthesize_note", new_callable=AsyncMock, return_value=("Research: test topic", "body")), \
         patch("fabledassistant.services.research.create_note", new_callable=AsyncMock, return_value=fallback_note):
        from fabledassistant.services.research import run_research_pipeline
        result = await run_research_pipeline("test topic", user_id=1, model="test-model")
    assert result.id == 77
Author	SHA1	Message	Date
bvandeusen	d8945536c4	Merge pull request 'Release v26.04.08.2 — Knowledge consolidation + Modern Fable identity' (#25 ) from dev into main	2026-04-08 15:40:12 +00:00
bvandeusen	f30e90ef8d	feat: narrator empty states, scroll fades, glow buttons, violet color sweep	2026-04-08 11:17:06 -04:00
bvandeusen	00f82f8cba	feat(knowledge): card type DNA, violet hover bloom, amber timestamps, narrator empty states Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-08 11:14:31 -04:00
bvandeusen	f953a36b86	feat(header): pill nav bar, brand shortening, status pulse, header gradient	2026-04-08 11:11:35 -04:00
bvandeusen	4bc7f9eaac	feat(theme): shift palette from indigo to deep violet + muted gold Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-08 11:09:23 -04:00
bvandeusen	670de547ad	docs: add Modern Fable visual identity implementation plan	2026-04-08 10:43:20 -04:00
bvandeusen	a684d84edf	feat: deprecate /notes and /tasks routes; redirect to Knowledge view	2026-04-08 10:35:21 -04:00
bvandeusen	34729cf1cf	feat(knowledge): add task cards with status/priority/due-date display	2026-04-08 10:32:51 -04:00
bvandeusen	dd16b39218	feat(knowledge): include tasks in knowledge queries and counts	2026-04-08 10:27:31 -04:00
bvandeusen	0bd362f582	docs: add Knowledge task consolidation implementation plan	2026-04-08 10:11:25 -04:00
bvandeusen	0afa2d8771	docs: add Modern Fable visual identity design spec	2026-04-08 10:04:55 -04:00
bvandeusen	93af4e6bab	docs: add Knowledge view task consolidation design spec	2026-04-08 09:47:11 -04:00
bvandeusen	6e3de91a6f	Merge pull request 'fix: resume AudioContext for silence detection' (#24 ) from dev into main	2026-04-08 12:37:16 +00:00
bvandeusen	6e0c528126	fix(voice): resume AudioContext to prevent suspended state blocking silence detection	2026-04-07 22:54:41 -04:00
bvandeusen	dd3b59ed36	Merge pull request 'Release v26.04.07.3' (#23 ) from dev into main	2026-04-08 00:43:11 +00:00
bvandeusen	56b687c9f4	fix(voice): show mic button on HTTP; graceful error for non-secure contexts	2026-04-07 20:06:57 -04:00
bvandeusen	6d57840dc7	fix(voice): re-check voice status on tab visibility change and after saving voice settings	2026-04-07 20:01:47 -04:00
bvandeusen	7f37cee49f	refactor(voice): integrate click-to-toggle mic into ChatInputBar; remove VoiceOverlay	2026-04-07 13:17:25 -04:00
bvandeusen	39e554d938	fix: rewrite title generator to only use user messages; bump background model to qwen2.5:3b	2026-04-07 12:53:33 -04:00
bvandeusen	b3cf42863a	fix: reinforce no-project-inference in system prompt; filter tool messages from title generation	2026-04-07 12:45:08 -04:00
bvandeusen	d290bebad2	feat(stt): pass conversation context as Whisper initial_prompt to reduce mishearings	2026-04-07 08:48:27 -04:00
bvandeusen	58e5c6bc60	Merge pull request 'Release v26.04.07.2' (#22 ) from dev into main	2026-04-07 12:39:52 +00:00
bvandeusen	d3170e5545	fix(chat): fetch full article content in from-article endpoint	2026-04-07 08:13:40 -04:00
bvandeusen	814f44c3fb	fix(push): fix VAPID key format and add regenerate endpoint + UI button	2026-04-07 06:59:06 -04:00
bvandeusen	1d0cf4828b	fix(briefing): fetch full article content via trafilatura in discuss endpoint	2026-04-07 06:55:15 -04:00
bvandeusen	56f1c44b8e	Release v26.04.07.1	2026-04-07 02:40:27 +00:00
bvandeusen	a5e35f7c72	feat: mount VoiceOverlay and wire Space bar shortcut in App.vue	2026-04-06 20:20:19 -04:00
bvandeusen	853dc810ff	feat: click-to-toggle silence detection and amplitude bars in VoiceOverlay	2026-04-06 20:01:44 -04:00
bvandeusen	ac7dde472f	feat: expose live stream ref from useVoiceRecorder	2026-04-06 20:00:22 -04:00
bvandeusen	84926d4ba2	feat: add useSilenceDetector composable with Web Audio API amplitude monitoring	2026-04-06 19:48:32 -04:00
bvandeusen	9b69e38aff	docs: add web voice overlay polish implementation plan	2026-04-06 19:40:56 -04:00
bvandeusen	1b68559bfe	docs: add web voice overlay polish spec	2026-04-06 19:39:27 -04:00
bvandeusen	edf0a9063e	fix: prevent model from inferring project names on create_task/create_note The model was hallucinating project names from task/note content (e.g. inferring "Vehicle Maintenance" from "purchase wheel bearings"). Added explicit guidance to both project field descriptions: only set if the user explicitly named a project, never infer from content. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-06 19:17:43 -04:00
bvandeusen	f2c2117b25	Merge pull request 'feat: add News link to main navigation header' (#20 ) from dev into main	2026-04-06 22:20:27 +00:00
bvandeusen	b9d0716b01	feat: add News link to main navigation header Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-06 17:49:22 -04:00
bvandeusen	9af8ab8f70	fix(briefing): use briefing context for follow-ups; add slot separator - build_context: when conversation_type is 'briefing', inject a system prompt instruction telling the model to answer from conversation history and article context instead of searching the web - Consolidate briefing conversation type detection to one DB query (was being checked twice — once for the system prompt addition, once for article context injection) - ChatPanel: render a visual 'New Briefing Update' separator line before 2nd+ briefing slot messages (identified by metadata.rss_item_ids) - types/chat.ts: add metadata field to Message interface Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-06 06:15:18 -04:00
bvandeusen	a171210224	feat(tools): confirmed guard for deletes, update_person/place, get/update_profile, calculate - delete_note / delete_task: add confirmed parameter + requires_confirmation guard (find the note first, then ask, consistent with create_note/task pattern) - get_note: description now mentions notes AND tasks - update_person / update_place: new tools to update existing entity notes in-place - get_profile / update_profile: surface and edit the user's stored profile (expertise, tone, response style, job title, interests) - calculate: eval math expressions via Python math module; solves precision issues on multi-step arithmetic and supports sqrt/log/trig/etc. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-05 22:58:14 -04:00
bvandeusen	eb92b2a976	feat(research): multi-note pipeline — outline + parallel section synthesis + index note Replaces the single monolithic research note with topic-driven section notes plus an index note. Two new LLM calls: _generate_outline (JSON outline, 3-8 sections) and _synthesize_section (300-600 word focused note per section, parallelised via asyncio.gather). Public signature of run_research_pipeline unchanged; falls back to single-note synthesis on outline failure or if all sections fail. Also extracts _build_sources_block helper and adds full test suite. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-05 22:53:14 -04:00
bvandeusen	be805073a7	docs: add research multi-note redesign spec	2026-04-05 22:42:51 -04:00
bvandeusen	e4c812a603	feat(voice): improve TTS logging for root-cause diagnosis - Route now logs every synthesis request (char count, voice, speed) - Route logs char count + text preview when the 8000-char limit is hit - Route logs empty audio with preview (helps spot no-chunk-produced edge case) - Route logs success with byte count and duration - Kokoro synthesise() logs per-call: samples produced, elapsed, chars/s - Kokoro synthesise() logs warning when zero audio chunks returned with preview - Kokoro synthesise() catches and logs pipeline-internal errors with preview - Frontend: console.warn now includes char count + 80-char preview on failure and retry Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-04-05 22:36:43 -04:00