Files

jake 103585d7ea feat(plan): add Phase 2 functional MVP implementation plan

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

2026-03-21 12:10:26 +00:00

28 KiB

Raw Blame History

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

SQLite migration v2: Add priority, project, status, updated_at to tasks; add FTS5 virtual table for transcripts
Tauri commands for task CRUD: Replace localStorage task management with SQLite backend
Tauri commands for transcript persistence: Save transcriptions to SQLite (currently only localStorage)
FTS5 full-text search: Backend search across transcriptions
llama-cpp-2 integration: Wire LLM inference engine for task extraction + micro-stepping
LLM model management: Download/cache GGUF models (Phi-4-mini, Qwen 3 7B)
Micro-stepping UI: Inline micro-steps below parent tasks with "Just Start" timer
VisualTimer wiring: Connect timer to tasks, add notifications
Export to Obsidian: Markdown with YAML frontmatter
Global hotkey update: Change default from Ctrl+Shift+R to Ctrl+Shift+Space
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:

(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:

// 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

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

cd crates/storage && cargo test

Step 5: Verify Tauri app compiles

cd src-tauri && cargo check

Step 6: Commit

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

// 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

cd src-tauri && cargo check

Step 5: Commit

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:

#[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:

#[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

cd src-tauri && cargo check

Step 4: Commit

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:

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

npm run build

Step 6: Commit

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

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

npm run build

Step 5: Commit

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

[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

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:

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

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

cargo check -p kon-llm

Step 6: Commit

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

#[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

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

cd src-tauri && cargo check && cd .. && npm run build

Step 8: Commit

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

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

cd src-tauri && cargo check && cd .. && npm run build

Step 5: Commit

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

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

<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

npm run build

Step 6: Commit

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

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:

<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

cd src-tauri && cargo check && cd .. && npm run build

Step 6: Commit

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

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

npm run build

Step 5: Commit

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

npm run build

Step 6: Commit

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

npm run build

Step 6: Commit

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

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

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).

28 KiB Raw Blame History Unescape Escape

Kon Phase 2: Functional MVP — Implementation Plan

Existing State Summary

Already Working

Needs Building

File Map

New files to create

Files to modify

Phase 2A — Core Pipeline

Task 1: SQLite Migration v2 — Schema Extensions

Task 2: Tauri Commands for Transcript Persistence

Task 3: Tauri Commands for Task CRUD

Task 4: Frontend Task Store Migration (localStorage → SQLite)

Task 5: Frontend History Store Migration

Phase 2B — Intelligence Layer

Task 6: LLM Crate + llama-cpp-2 Integration

Task 7: LLM Tauri Commands + Model Download UI

Task 8: Task Extraction — LLM + Rule-Based Fallback

Task 9: Micro-Stepping

Task 10: Visual Timer Wiring + Notifications

Phase 2C — Data & Polish

Task 11: Export and Open Data

Task 12: First Run Polish

Task 13: Settings Wiring + Global Hotkey Update

Task 14: Final Validation

Summary

28 KiB

Raw Blame History