diff --git a/docs/superpowers/plans/2026-03-21-phase2-functional-mvp.md b/docs/superpowers/plans/2026-03-21-phase2-functional-mvp.md
new file mode 100644
index 0000000..30447a0
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-21-phase2-functional-mvp.md
@@ -0,0 +1,902 @@
+# Kon Phase 2: Functional MVP — 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:** Transform Kon from a branded shell into a functional voice → text → tasks pipeline with local LLM intelligence, delivering a shippable closed-beta desktop app.
+
+**Architecture:** The existing codebase has a working audio capture → Whisper transcription → text display pipeline via browser AudioWorklet + Tauri IPC. Phase 2 migrates persistence from localStorage to SQLite (backend already has schema + CRUD), adds FTS5 search, wires llama-cpp-2 for local LLM task extraction and micro-stepping, connects the VisualTimer to tasks, and polishes first-run + settings + export.
+
+**Tech Stack:** Svelte 5, SvelteKit 2, Tailwind CSS 4.2, Tauri 2, Rust, sqlx (SQLite), whisper-rs (via transcribe-rs), llama-cpp-2, lucide-svelte
+
+**Branch:** `phase-2/functional-mvp`
+
+**Commit format:** `feat(scope): description`
+
+---
+
+## Existing State Summary
+
+### Already Working
+- Microphone capture via browser AudioWorklet → 16kHz mono PCM
+- Whisper + Parakeet transcription via transcribe-rs (streaming chunks)
+- Model download/load/cache management
+- Text post-processing (filler removal, British English, anti-hallucination)
+- Rule-based task extraction (frontend JS — `taskExtractor.js`)
+- Task CRUD in localStorage with BroadcastChannel multi-window sync
+- History in localStorage with playback
+- File transcription (drag-drop, multi-format)
+- Preferences store with SQLite persistence
+- Full brand token system, accessibility controls, sensory zones
+
+### Needs Building
+1. **SQLite migration v2**: Add `priority`, `project`, `status`, `updated_at` to tasks; add FTS5 virtual table for transcripts
+2. **Tauri commands for task CRUD**: Replace localStorage task management with SQLite backend
+3. **Tauri commands for transcript persistence**: Save transcriptions to SQLite (currently only localStorage)
+4. **FTS5 full-text search**: Backend search across transcriptions
+5. **llama-cpp-2 integration**: Wire LLM inference engine for task extraction + micro-stepping
+6. **LLM model management**: Download/cache GGUF models (Phi-4-mini, Qwen 3 7B)
+7. **Micro-stepping UI**: Inline micro-steps below parent tasks with "Just Start" timer
+8. **VisualTimer wiring**: Connect timer to tasks, add notifications
+9. **Export to Obsidian**: Markdown with YAML frontmatter
+10. **Global hotkey update**: Change default from Ctrl+Shift+R to Ctrl+Shift+Space
+11. **Settings backend wiring**: Migrate remaining settings to SQLite preferences
+
+---
+
+## File Map
+
+### New files to create
+
+| File | Purpose |
+|---|---|
+| `crates/ai-formatting/src/llm_client.rs` | llama-cpp-2 inference wrapper (rewrite from placeholder) |
+| `crates/ai-formatting/src/task_extraction.rs` | LLM-based task extraction with fallback to rule-based |
+| `crates/ai-formatting/src/micro_stepping.rs` | Task decomposition into micro-steps |
+| `crates/llm/Cargo.toml` | New crate for LLM model management |
+| `crates/llm/src/lib.rs` | LLM engine wrapper |
+| `crates/llm/src/model_manager.rs` | GGUF model download/cache |
+| `crates/llm/src/inference.rs` | Token streaming inference |
+| `src-tauri/src/commands/tasks.rs` | Task CRUD Tauri commands |
+| `src-tauri/src/commands/history.rs` | Transcript persistence + FTS5 search commands |
+| `src-tauri/src/commands/llm.rs` | LLM model management + inference commands |
+| `src/lib/components/MicroSteps.svelte` | Micro-step display + "Just Start" button |
+| `src/lib/components/TaskTimer.svelte` | Timer wired to specific task |
+| `src/lib/stores/tasks.svelte.js` | Task store backed by SQLite via Tauri commands |
+| `src/lib/stores/history.svelte.js` | History store backed by SQLite |
+| `src/lib/utils/obsidianExport.js` | Obsidian vault export logic |
+
+### Files to modify
+
+| File | Changes |
+|---|---|
+| `crates/storage/src/migrations.rs` | Add migration v2 (FTS5, task columns, timer state) |
+| `crates/storage/src/database.rs` | Add task CRUD with new columns, FTS5 search, timer persistence |
+| `crates/ai-formatting/Cargo.toml` | Add serde, serde_json dependencies |
+| `src-tauri/Cargo.toml` | Add llama-cpp-2, tauri-plugin-notification |
+| `src-tauri/src/lib.rs` | Register new commands, add LLM state |
+| `src-tauri/src/commands/mod.rs` | Add new command modules |
+| `src/lib/pages/DictationPage.svelte` | Wire SQLite transcript persistence |
+| `src/lib/pages/TasksPage.svelte` | Wire SQLite task CRUD, add micro-steps |
+| `src/lib/pages/HistoryPage.svelte` | Wire FTS5 search, SQLite history |
+| `src/lib/pages/FilesPage.svelte` | Wire SQLite persistence for file transcriptions |
+| `src/lib/pages/FirstRunPage.svelte` | Add LLM model download step |
+| `src/lib/pages/SettingsPage.svelte` | Wire remaining settings to backend |
+| `src/lib/stores/page.svelte.js` | Remove localStorage task/history stores (migrate to new stores) |
+| `src/lib/components/WipTaskList.svelte` | Add micro-step expansion, timer button |
+| `src/lib/components/VisualTimer.svelte` | Add countdown logic, notifications |
+| `src/lib/components/ModelDownloader.svelte` | Support LLM model downloads |
+| `Cargo.toml` | Add crates/llm to workspace |
+
+---
+
+## Phase 2A — Core Pipeline
+
+### Task 1: SQLite Migration v2 — Schema Extensions
+
+**Files:**
+- Modify: `crates/storage/src/migrations.rs`
+- Modify: `crates/storage/src/database.rs`
+- Modify: `crates/storage/Cargo.toml`
+
+**Why first:** Everything else depends on the database schema being right.
+
+- [ ] **Step 1: Add migration v2 to migrations.rs**
+
+Add after the existing migration v1 entry in the `MIGRATIONS` array:
+
+```rust
+(2, "phase 2 — task fields, FTS5, timer state", r#"
+    ALTER TABLE tasks ADD COLUMN priority TEXT NOT NULL DEFAULT 'medium';
+    ALTER TABLE tasks ADD COLUMN project TEXT;
+    ALTER TABLE tasks ADD COLUMN status TEXT NOT NULL DEFAULT 'pending';
+    ALTER TABLE tasks ADD COLUMN updated_at TEXT NOT NULL DEFAULT (datetime('now'));
+    ALTER TABLE tasks ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0;
+    ALTER TABLE tasks ADD COLUMN notes TEXT NOT NULL DEFAULT '';
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS transcripts_fts USING fts5(
+        text,
+        title,
+        content='transcripts',
+        content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS transcripts_ai AFTER INSERT ON transcripts BEGIN
+        INSERT INTO transcripts_fts(rowid, text, title)
+        VALUES (new.rowid, new.text, new.title);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS transcripts_ad AFTER DELETE ON transcripts BEGIN
+        INSERT INTO transcripts_fts(transcripts_fts, rowid, text, title)
+        VALUES ('delete', old.rowid, old.text, old.title);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS transcripts_au AFTER UPDATE ON transcripts BEGIN
+        INSERT INTO transcripts_fts(transcripts_fts, rowid, text, title)
+        VALUES ('delete', old.rowid, old.text, old.title);
+        INSERT INTO transcripts_fts(rowid, text, title)
+        VALUES (new.rowid, new.text, new.title);
+    END;
+
+    CREATE TABLE IF NOT EXISTS timer_state (
+        id TEXT PRIMARY KEY DEFAULT 'active',
+        task_id TEXT NOT NULL,
+        total_seconds INTEGER NOT NULL,
+        remaining_seconds INTEGER NOT NULL,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        paused INTEGER NOT NULL DEFAULT 0
+    )
+"#),
+```
+
+- [ ] **Step 2: Add new database functions to database.rs**
+
+Add task functions with new columns:
+
+```rust
+// Task CRUD with extended fields
+pub async fn insert_task_v2(pool, id, text, priority, project, status, bucket, effort, source_transcript_id, sort_order) -> Result<()>
+pub async fn update_task_v2(pool, id, text, priority, project, status, bucket, effort, notes) -> Result<()>
+pub async fn reorder_tasks(pool, task_ids: &[String]) -> Result<()>
+pub async fn list_tasks_by_status(pool, status, limit) -> Result<Vec<TaskRow>>
+pub async fn search_transcripts(pool, query: &str, limit: i64) -> Result<Vec<TranscriptRow>>
+
+// Timer state persistence
+pub async fn save_timer_state(pool, task_id, total_seconds, remaining_seconds, paused) -> Result<()>
+pub async fn get_timer_state(pool) -> Result<Option<TimerStateRow>>
+pub async fn clear_timer_state(pool) -> Result<()>
+```
+
+- [ ] **Step 3: Add FTS5 search function**
+
+```rust
+pub async fn search_transcripts(pool: &SqlitePool, query: &str, limit: i64) -> Result<Vec<TranscriptRow>> {
+    let rows = sqlx::query(
+        "SELECT t.id, t.text, t.source, t.title, t.audio_path, t.duration, t.engine, t.model_id, t.inference_ms, t.sample_rate, t.audio_channels, t.format_mode, t.remove_fillers, t.british_english, t.anti_hallucination, t.created_at
+         FROM transcripts t
+         JOIN transcripts_fts fts ON t.rowid = fts.rowid
+         WHERE transcripts_fts MATCH ?1
+         ORDER BY rank
+         LIMIT ?2"
+    )
+    .bind(query)
+    .bind(limit)
+    .fetch_all(pool)
+    .await
+    .map_err(|e| KonError::StorageError(format!("FTS search failed: {e}")))?;
+    Ok(rows.iter().map(transcript_row_from).collect())
+}
+```
+
+- [ ] **Step 4: Run tests**
+
+```bash
+cd crates/storage && cargo test
+```
+
+- [ ] **Step 5: Verify Tauri app compiles**
+
+```bash
+cd src-tauri && cargo check
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add crates/storage/
+git commit -m "feat(storage): add migration v2 — task fields, FTS5 search, timer state"
+```
+
+---
+
+### Task 2: Tauri Commands for Transcript Persistence
+
+**Files:**
+- Create: `src-tauri/src/commands/history.rs`
+- Modify: `src-tauri/src/commands/mod.rs`
+- Modify: `src-tauri/src/lib.rs`
+- Modify: `src-tauri/src/commands/transcription.rs`
+
+- [ ] **Step 1: Create history.rs with transcript CRUD commands**
+
+```rust
+// save_transcript — persist completed transcription to SQLite
+// get_transcript — fetch by ID
+// list_transcripts — paginated list, newest first
+// delete_transcript — remove by ID
+// search_transcripts — FTS5 search
+// save_segments — batch insert segments for a transcript
+```
+
+- [ ] **Step 2: Register commands in mod.rs and lib.rs**
+
+- [ ] **Step 3: Modify transcription.rs to auto-persist**
+
+After successful transcription, auto-save the transcript + segments to SQLite (in addition to emitting the event).
+
+- [ ] **Step 4: Verify compilation**
+
+```bash
+cd src-tauri && cargo check
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src-tauri/
+git commit -m "feat(history): add Tauri commands for transcript persistence and FTS5 search"
+```
+
+---
+
+### Task 3: Tauri Commands for Task CRUD
+
+**Files:**
+- Create: `src-tauri/src/commands/tasks.rs`
+- Modify: `src-tauri/src/commands/mod.rs`
+- Modify: `src-tauri/src/lib.rs`
+
+- [ ] **Step 1: Create tasks.rs**
+
+Commands:
+```rust
+#[tauri::command] async fn create_task(state, text, priority, project, bucket, effort, source_transcript_id) -> Result<TaskResponse, String>
+#[tauri::command] async fn update_task(state, id, text, priority, project, status, bucket, effort, notes) -> Result<(), String>
+#[tauri::command] async fn delete_task(state, id) -> Result<(), String>
+#[tauri::command] async fn list_tasks(state, status, limit) -> Result<Vec<TaskResponse>, String>
+#[tauri::command] async fn reorder_tasks(state, task_ids: Vec<String>) -> Result<(), String>
+#[tauri::command] async fn complete_task(state, id) -> Result<(), String>
+```
+
+TaskResponse struct:
+```rust
+#[derive(Serialize)]
+struct TaskResponse {
+    id: String,
+    text: String,
+    priority: String,
+    project: Option<String>,
+    status: String,
+    bucket: String,
+    effort: Option<String>,
+    done: bool,
+    done_at: Option<String>,
+    created_at: String,
+    updated_at: String,
+    sort_order: i64,
+    notes: String,
+    source_transcript_id: Option<String>,
+}
+```
+
+- [ ] **Step 2: Register commands in mod.rs and lib.rs**
+
+- [ ] **Step 3: Verify compilation**
+
+```bash
+cd src-tauri && cargo check
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src-tauri/
+git commit -m "feat(tasks): add Tauri commands for full task CRUD with priority, project, status"
+```
+
+---
+
+### Task 4: Frontend Task Store Migration (localStorage → SQLite)
+
+**Files:**
+- Create: `src/lib/stores/tasks.svelte.js`
+- Modify: `src/lib/pages/TasksPage.svelte`
+- Modify: `src/lib/components/WipTaskList.svelte`
+- Modify: `src/lib/stores/page.svelte.js`
+
+- [ ] **Step 1: Create tasks.svelte.js**
+
+New store that wraps Tauri commands instead of localStorage:
+
+```javascript
+import { invoke } from '@tauri-apps/api/core';
+
+let tasks = $state([]);
+let loading = $state(false);
+
+export async function loadTasks() { ... }
+export async function createTask(text, opts = {}) { ... }
+export async function updateTask(id, updates) { ... }
+export async function deleteTask(id) { ... }
+export async function completeTask(id) { ... }
+export async function reorderTasks(ids) { ... }
+export function getTasks() { return tasks; }
+```
+
+- [ ] **Step 2: Update TasksPage.svelte to use new store**
+
+Replace all `tasks` imports from page.svelte.js with the new SQLite-backed store.
+
+- [ ] **Step 3: Update WipTaskList.svelte**
+
+Wire to new task store.
+
+- [ ] **Step 4: Keep page.svelte.js tasks for backwards compat during migration**
+
+Add a bridge that loads from SQLite on mount, falls back to localStorage.
+
+- [ ] **Step 5: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/
+git commit -m "feat(tasks): migrate task store from localStorage to SQLite backend"
+```
+
+---
+
+### Task 5: Frontend History Store Migration
+
+**Files:**
+- Create: `src/lib/stores/history.svelte.js`
+- Modify: `src/lib/pages/HistoryPage.svelte`
+- Modify: `src/lib/pages/DictationPage.svelte`
+
+- [ ] **Step 1: Create history.svelte.js**
+
+```javascript
+import { invoke } from '@tauri-apps/api/core';
+
+let transcripts = $state([]);
+
+export async function loadHistory(limit = 100) { ... }
+export async function saveTranscript(transcript) { ... }
+export async function deleteTranscript(id) { ... }
+export async function searchTranscripts(query) { ... }
+export function getHistory() { return transcripts; }
+```
+
+- [ ] **Step 2: Update HistoryPage.svelte**
+
+Replace localStorage-based history with SQLite search. Wire FTS5 search to the search input.
+
+- [ ] **Step 3: Update DictationPage.svelte**
+
+After transcription completes, call `saveTranscript()` from the new store (in addition to existing behaviour).
+
+- [ ] **Step 4: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/
+git commit -m "feat(history): migrate history to SQLite with FTS5 search"
+```
+
+---
+
+## Phase 2B — Intelligence Layer
+
+### Task 6: LLM Crate + llama-cpp-2 Integration
+
+**Files:**
+- Create: `crates/llm/Cargo.toml`
+- Create: `crates/llm/src/lib.rs`
+- Create: `crates/llm/src/inference.rs`
+- Create: `crates/llm/src/model_manager.rs`
+- Modify: `Cargo.toml` (workspace members)
+- Modify: `src-tauri/Cargo.toml` (add dependency)
+
+**Note:** llama-cpp-2 requires CMake and a C++ compiler. On Windows this means MSVC build tools.
+
+- [ ] **Step 1: Create crates/llm/Cargo.toml**
+
+```toml
+[package]
+name = "kon-llm"
+version = "0.1.0"
+edition = "2021"
+description = "Local LLM inference via llama.cpp for Kon"
+
+[dependencies]
+kon-core = { path = "../core" }
+llama-cpp-2 = { version = "0.1", features = ["vulkan"] }
+tokio = { version = "1", features = ["rt", "sync"] }
+reqwest = { version = "0.12", features = ["stream"] }
+futures-util = "0.3"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+log = "0.4"
+```
+
+- [ ] **Step 2: Create lib.rs with LlmEngine struct**
+
+```rust
+pub struct LlmEngine {
+    model: Mutex<Option<LlamaModel>>,
+    loaded_model_path: Mutex<Option<PathBuf>>,
+}
+
+impl LlmEngine {
+    pub fn new() -> Self { ... }
+    pub fn load(&self, model_path: &Path) -> Result<()> { ... }
+    pub fn is_loaded(&self) -> bool { ... }
+    pub fn generate(&self, prompt: &str, max_tokens: u32) -> Result<String> { ... }
+    pub fn generate_streaming(&self, prompt: &str, max_tokens: u32, callback: impl Fn(&str)) -> Result<String> { ... }
+}
+```
+
+- [ ] **Step 3: Create model_manager.rs for GGUF downloads**
+
+Reuse the pattern from crates/transcription/model_manager.rs — streaming download with progress callback, atomic rename.
+
+Model catalog:
+```rust
+const LLM_MODELS: &[LlmModelEntry] = &[
+    LlmModelEntry {
+        id: "phi-4-mini-q4",
+        display_name: "Phi-4 Mini (8GB RAM)",
+        url: "https://huggingface.co/...",
+        disk_size: Megabytes(2300),
+        ram_required: Megabytes(4000),
+        filename: "phi-4-mini-q4_k_m.gguf",
+    },
+    LlmModelEntry {
+        id: "qwen3-7b-q4",
+        display_name: "Qwen 3 7B (16GB RAM)",
+        url: "https://huggingface.co/...",
+        disk_size: Megabytes(4500),
+        ram_required: Megabytes(8000),
+        filename: "qwen3-7b-q4_k_m.gguf",
+    },
+];
+```
+
+- [ ] **Step 4: Create inference.rs with async wrapper**
+
+```rust
+pub async fn run_llm_inference(
+    engine: Arc<LlmEngine>,
+    prompt: String,
+    max_tokens: u32,
+) -> Result<String> {
+    tokio::task::spawn_blocking(move || {
+        engine.generate(&prompt, max_tokens)
+    }).await.map_err(|e| KonError::Other(e.to_string()))?
+}
+```
+
+- [ ] **Step 5: Add workspace member and verify compilation**
+
+```bash
+cargo check -p kon-llm
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add crates/llm/ Cargo.toml
+git commit -m "feat(llm): add kon-llm crate with llama-cpp-2 inference engine"
+```
+
+---
+
+### Task 7: LLM Tauri Commands + Model Download UI
+
+**Files:**
+- Create: `src-tauri/src/commands/llm.rs`
+- Modify: `src-tauri/src/commands/mod.rs`
+- Modify: `src-tauri/src/lib.rs`
+- Modify: `src/lib/pages/SettingsPage.svelte`
+- Modify: `src/lib/components/ModelDownloader.svelte`
+- Modify: `src/lib/pages/FirstRunPage.svelte`
+
+- [ ] **Step 1: Create llm.rs with commands**
+
+```rust
+#[tauri::command] async fn list_llm_models() -> Vec<LlmModelInfo>
+#[tauri::command] async fn download_llm_model(app, id) -> Result<(), String>  // emits "llm-download-progress"
+#[tauri::command] async fn load_llm_model(state, id) -> Result<(), String>
+#[tauri::command] async fn check_llm_engine(state) -> bool
+#[tauri::command] async fn llm_generate(state, prompt, max_tokens) -> Result<String, String>
+#[tauri::command] async fn extract_tasks_llm(state, transcript_text) -> Result<Vec<TaskSuggestion>, String>
+#[tauri::command] async fn decompose_task(state, task_text) -> Result<Vec<MicroStep>, String>
+```
+
+- [ ] **Step 2: Add LlmEngine to AppState**
+
+```rust
+pub struct AppState {
+    pub whisper_engine: Arc<LocalEngine>,
+    pub parakeet_engine: Arc<LocalEngine>,
+    pub llm_engine: Arc<LlmEngine>,
+    pub db: SqlitePool,
+}
+```
+
+- [ ] **Step 3: Register commands in lib.rs**
+
+- [ ] **Step 4: Update ModelDownloader.svelte to support LLM models**
+
+Add a `modelType` prop ("whisper" | "llm") and listen to appropriate download events.
+
+- [ ] **Step 5: Add LLM model section to FirstRunPage.svelte**
+
+After STT model download, offer optional LLM model download: "Download AI assistant for task extraction? (optional, {size})"
+
+- [ ] **Step 6: Add LLM section to SettingsPage.svelte**
+
+In the "AI Assistant" accordion: model selection, download button, status indicator.
+
+- [ ] **Step 7: Verify build**
+
+```bash
+cd src-tauri && cargo check && cd .. && npm run build
+```
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add src-tauri/ src/ crates/llm/
+git commit -m "feat(llm): add LLM Tauri commands, model download UI, FirstRun integration"
+```
+
+---
+
+### Task 8: Task Extraction — LLM + Rule-Based Fallback
+
+**Files:**
+- Rewrite: `crates/ai-formatting/src/llm_client.rs` (replace placeholder)
+- Create: `crates/ai-formatting/src/task_extraction.rs`
+- Modify: `crates/ai-formatting/Cargo.toml`
+- Modify: `crates/ai-formatting/src/lib.rs`
+- Modify: `src-tauri/src/commands/llm.rs`
+- Modify: `src/lib/pages/DictationPage.svelte`
+
+- [ ] **Step 1: Create task_extraction.rs**
+
+```rust
+pub struct ExtractedTask {
+    pub title: String,
+    pub priority: String,
+    pub project: Option<String>,
+}
+
+const EXTRACTION_SYSTEM_PROMPT: &str = r#"Extract actionable tasks from the following voice transcription. Each task must start with a concrete verb. Return as JSON array of {"title": "...", "priority": "high|medium|low", "project": "..."}.
+Only extract genuine tasks — not observations or comments. If no tasks found, return empty array []."#;
+
+pub fn extract_tasks_with_llm(engine: &LlmEngine, transcript: &str) -> Result<Vec<ExtractedTask>> { ... }
+pub fn extract_tasks_rule_based(transcript: &str) -> Vec<ExtractedTask> { ... }
+pub fn extract_tasks(engine: Option<&LlmEngine>, transcript: &str) -> Vec<ExtractedTask> { ... }
+```
+
+- [ ] **Step 2: Wire into extract_tasks_llm command**
+
+The Tauri command tries LLM first, falls back to rule-based.
+
+- [ ] **Step 3: Update DictationPage.svelte**
+
+Replace the JS `extractTasks()` call with `invoke('extract_tasks_llm', { transcriptText })`.
+
+- [ ] **Step 4: Verify build**
+
+```bash
+cd src-tauri && cargo check && cd .. && npm run build
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add crates/ai-formatting/ src-tauri/ src/
+git commit -m "feat(extraction): add LLM task extraction with rule-based fallback"
+```
+
+---
+
+### Task 9: Micro-Stepping
+
+**Files:**
+- Create: `crates/ai-formatting/src/micro_stepping.rs`
+- Create: `src/lib/components/MicroSteps.svelte`
+- Modify: `src/lib/components/WipTaskList.svelte`
+- Modify: `src-tauri/src/commands/llm.rs`
+
+- [ ] **Step 1: Create micro_stepping.rs**
+
+```rust
+const MICRO_STEP_PROMPT: &str = r#"Break this task into 3-7 micro-steps. Each step MUST start with a specific physical verb (e.g. 'Open', 'Type', 'Click', 'Pick up'). Each step must be completable in under 5 minutes. Never use abstract verbs like 'organise', 'plan', 'consider'. Return as JSON array of strings."#;
+
+pub fn decompose_task(engine: &LlmEngine, task_text: &str) -> Result<Vec<String>> { ... }
+```
+
+- [ ] **Step 2: Wire into decompose_task Tauri command**
+
+- [ ] **Step 3: Create MicroSteps.svelte**
+
+```svelte
+<script>
+  import { invoke } from '@tauri-apps/api/core';
+  import { Play } from 'lucide-svelte';
+  let { taskId, taskText } = $props();
+  let steps = $state([]);
+  let loading = $state(false);
+  // ...
+</script>
+```
+
+Shows expandable micro-steps below a task. Each step has a "Just Start" button that launches a 2min or 5min timer.
+
+- [ ] **Step 4: Wire MicroSteps into WipTaskList**
+
+Add expand/collapse per task that loads micro-steps on demand.
+
+- [ ] **Step 5: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add crates/ai-formatting/ src-tauri/ src/
+git commit -m "feat(microsteps): add LLM task decomposition with Just Start timer"
+```
+
+---
+
+### Task 10: Visual Timer Wiring + Notifications
+
+**Files:**
+- Modify: `src/lib/components/VisualTimer.svelte`
+- Create: `src/lib/components/TaskTimer.svelte`
+- Modify: `src-tauri/Cargo.toml` (add tauri-plugin-notification)
+- Modify: `src-tauri/src/lib.rs` (register notification plugin)
+- Modify: `src-tauri/tauri.conf.json` (add notification permission)
+
+- [ ] **Step 1: Add tauri-plugin-notification**
+
+```bash
+cd src-tauri && cargo add tauri-plugin-notification@2
+```
+
+Update lib.rs: `.plugin(tauri_plugin_notification::init())`
+
+Update tauri.conf.json capabilities.
+
+- [ ] **Step 2: Create TaskTimer.svelte**
+
+Wraps VisualTimer with countdown logic, persists timer state to SQLite, shows OS notification on complete:
+
+```svelte
+<script>
+  import VisualTimer from './VisualTimer.svelte';
+  import { invoke } from '@tauri-apps/api/core';
+  import { sendNotification } from '@tauri-apps/plugin-notification';
+  // Timer countdown, pause/resume, persist state
+</script>
+```
+
+- [ ] **Step 3: Wire timer persistence**
+
+On start: `invoke('save_timer_state', { taskId, totalSeconds, remainingSeconds })`
+On tick: Update remaining (debounced, every 5s)
+On complete: `invoke('clear_timer_state')` + notification
+On app restart: `invoke('get_timer_state')` → resume timer
+
+- [ ] **Step 4: Respect reduce-motion preference**
+
+When reduce motion is on, VisualTimer shows static fill state instead of animated ring.
+
+- [ ] **Step 5: Verify build**
+
+```bash
+cd src-tauri && cargo check && cd .. && npm run build
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src-tauri/ src/
+git commit -m "feat(timer): wire VisualTimer to tasks with notifications and persistence"
+```
+
+---
+
+## Phase 2C — Data & Polish
+
+### Task 11: Export and Open Data
+
+**Files:**
+- Create: `src/lib/utils/obsidianExport.js`
+- Modify: `src/lib/pages/DictationPage.svelte`
+- Modify: `src/lib/pages/HistoryPage.svelte`
+- Modify: `src/lib/pages/TasksPage.svelte`
+
+- [ ] **Step 1: Create obsidianExport.js**
+
+```javascript
+export function exportTranscriptToObsidian(transcript, segments, tasks) {
+  const frontmatter = `---
+title: "${transcript.title || 'Voice Note'}"
+date: ${transcript.created_at}
+source: ${transcript.source}
+duration: ${transcript.duration}s
+engine: ${transcript.engine}
+tags: [kon, transcription]
+---\n\n`;
+  // ... body with text + optional task list
+}
+
+export function exportTasksToJSON(tasks) { ... }
+export function exportTasksToCSV(tasks) { ... }
+```
+
+- [ ] **Step 2: Add "Export to Obsidian" button to HistoryPage**
+
+Uses `@tauri-apps/plugin-dialog` to pick output directory, then writes markdown files.
+
+- [ ] **Step 3: Add task export to TasksPage**
+
+JSON and CSV export buttons.
+
+- [ ] **Step 4: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/
+git commit -m "feat(export): add Obsidian export, task JSON/CSV export"
+```
+
+---
+
+### Task 12: First Run Polish
+
+**Files:**
+- Modify: `src/lib/pages/FirstRunPage.svelte`
+- Modify: `src/lib/stores/page.svelte.js`
+
+- [ ] **Step 1: Add microphone permission request step**
+
+Before model download, request mic permission via `navigator.mediaDevices.getUserMedia()`.
+
+- [ ] **Step 2: Add test recording step**
+
+After model loads, show a quick 5-second test recording: "Say something..." → display result → "You're ready!"
+
+- [ ] **Step 3: Wire optional LLM download**
+
+After STT model: "Want smarter task extraction? Download AI assistant ({size}, optional)"
+
+- [ ] **Step 4: Time the flow — target under 90 seconds**
+
+Add performance instrumentation to log total onboarding time.
+
+- [ ] **Step 5: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/
+git commit -m "feat(firstrun): add mic permission, test recording, LLM download step"
+```
+
+---
+
+### Task 13: Settings Wiring + Global Hotkey Update
+
+**Files:**
+- Modify: `src/lib/pages/SettingsPage.svelte`
+- Modify: `src/lib/stores/page.svelte.js`
+- Modify: `src/routes/+layout.svelte`
+
+- [ ] **Step 1: Change default hotkey to Ctrl+Shift+Space**
+
+In `page.svelte.js`, change `globalHotkey: "Ctrl+Shift+R"` to `globalHotkey: "Ctrl+Shift+Space"`.
+
+- [ ] **Step 2: Add microphone selection setting**
+
+Use `navigator.mediaDevices.enumerateDevices()` to list audio input devices. Display as dropdown in Settings. Pass selected device ID to AudioContext.
+
+- [ ] **Step 3: Wire export directory setting**
+
+Use `@tauri-apps/plugin-dialog` for directory picker.
+
+- [ ] **Step 4: Migrate remaining localStorage settings to preferences store**
+
+The `settings` object in page.svelte.js currently uses localStorage. Add a `$effect` that syncs key settings to the SQLite-backed preferences store.
+
+- [ ] **Step 5: Verify build**
+
+```bash
+npm run build
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/
+git commit -m "feat(settings): wire mic selection, export directory, update default hotkey"
+```
+
+---
+
+### Task 14: Final Validation
+
+- [ ] **Step 1: Full build check**
+
+```bash
+npm run build && cd src-tauri && cargo check
+```
+
+- [ ] **Step 2: Keyboard navigation**
+
+Tab through every page. Verify focus rings visible.
+
+- [ ] **Step 3: Context restoration test**
+
+Set non-default preferences → close app → relaunch. Verify state preserved.
+
+- [ ] **Step 4: Reduce motion test**
+
+Toggle reduce motion on → verify all animations stopped, timer shows static state.
+
+- [ ] **Step 5: Commit any fixes**
+
+```bash
+git add -A
+git commit -m "fix(validation): final validation pass corrections"
+```
+
+---
+
+## Summary
+
+| Phase | Tasks | Key Deliverable |
+|---|---|---|
+| 2A: Core Pipeline (1–5) | Schema migration, transcript persistence, task CRUD, FTS5 search, frontend store migration | Working voice → text → SQLite pipeline |
+| 2B: Intelligence (6–10) | LLM crate, model management, task extraction, micro-stepping, visual timer | AI-powered task decomposition with timer |
+| 2C: Polish (11–14) | Export, first run, settings, validation | Ship-ready for closed beta |
+
+**Total:** 14 tasks. Schema first. Backend commands before frontend. LLM after core pipeline works. Polish last.
+
+**Critical path:** Task 1 (schema) → Task 2-3 (commands) → Task 4-5 (frontend migration) → Task 6-7 (LLM) → everything else.
+
+**Risk:** llama-cpp-2 compilation on Windows requires MSVC + CMake. If it fails, Tasks 6-9 scope down to rule-based extraction only (already works).