new version major refactorv0.2.0

30 files changed, 2614 insertions, 1327 deletions

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..f92a896
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,28 @@
+# Repository Guidelines
+
+## Code structur
+
+- Minimal entrace point, in ./cmd/yoga/main.go, all other code goes to the ./internal directory.
+
+## Coding Style & Naming Conventions
+
+- Avoid duplication of code when the functions are larger than 5 lines.
+- If possible, construct individual methods so that they can be unit tested. But only if it doesn't add too much boilerplate to the code base.
+- Aim for at least 85% unit test coverage of all source code. The command to check the coverage is "mage coverage"
+- Ensure that all unit tests pass before commiting any changes.
+- Always run the gofumpt code reformatter on all go files modified.
+- There should be no source code file larger than 1000 lines. If so, split it up into multiple.
+- There should be no function larger then 50 lines. If so, refactor or split up into multiple smaller functions.
+- Code (when added): follow language idioms
+- Any type with more than 3 methods should be in it's own source code file, whereas the filename contains the name of the type.
+
+## Incrementing version
+
+- Never draft a changelog entry
+- Whenever incrementing the version, update the version number in the project, commit to git, tag the version and push to git.
+- When a major feature was introduced, increment ?.X.?
+- When only minor changes were done or only bugs were fixed, increment the version as ?.?.X
+
+## Documentation
+
+- Document in the README all options and basic behaviour and also how to use the Magefile.
diff --git a/README.md b/README.md
index 1ea7a30..ad3ed2e 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,48 @@
 # Yoga
 
-A yoga video selector. Fully vibe-coded.
+Yoga is a TUI for browsing local yoga videos with quick filtering, duration probing, and one-key playback via VLC.
 
 ![Yoga](yoga.png)
+
+## Usage
+
+```bash
+yoga [--root PATH] [--crop WxH] [--version]
+```
+
+- `--root` sets the directory to scan for videos. When omitted, Yoga uses `~/Yoga` and creates it on first launch.
+- `--crop` supplies an optional VLC crop string (for example `5:4`). Toggle the crop at runtime with the `c` key.
+- `--version` prints the current version and exits.
+
+Yoga recognises common video extensions (`.mp4`, `.mkv`, `.mov`, `.avi`, `.wmv`, `.m4v`) and follows symlinks when scanning. Duration metadata is cached per directory in `.video_duration_cache.json`.
+
+### Keyboard Shortcuts
+
+- `↑/↓` – Navigate the table
+- `enter` – Play the selected video in VLC
+- `/` or `f` – Open the filter dialog
+- `r` – Reset filters
+- `n`, `l`, `a` – Sort by name, length, or age
+- `c` – Toggle VLC crop
+- `q` – Quit
+
+## Development
+
+The project uses [Mage](https://magefile.org/) for common tasks. Targets live in `magefile.go`.
+
+```bash
+mage build     # go build ./cmd/yoga
+mage test      # go test ./...
+mage install   # go install ./cmd/yoga
+mage coverage  # go test with coverage (fails if <85%)
+```
+
+Before sending changes:
+
+1. Format Go code with `gofumpt`.
+2. Run `mage test` and `mage coverage` to ensure the suite passes and coverage stays above 85%.
+3. Update documentation when flags or behaviour change.
+
+## Licensing
+
+This repository is released under the terms specified in the accompanying license file (if present).
diff --git a/cmd/yoga/main.go b/cmd/yoga/main.go
new file mode 100644
index 0000000..fbf11bd
--- /dev/null
+++ b/cmd/yoga/main.go
@@ -0,0 +1,50 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"yoga/internal/app"
+	"yoga/internal/fsutil"
+	"yoga/internal/meta"
+)
+
+const defaultRoot = "~/Yoga"
+
+var (
+	runApp = app.Run
+	exit   = os.Exit
+)
+
+func main() {
+	exit(run(os.Args[1:], os.Stdout, os.Stderr))
+}
+
+func run(args []string, stdout, stderr io.Writer) int {
+	fs := flag.NewFlagSet("yoga", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	rootFlag := fs.String("root", "", "Directory containing yoga videos (default ~/Yoga)")
+	cropFlag := fs.String("crop", "", "Optional crop aspect for VLC (e.g. 5:4)")
+	versionFlag := fs.Bool("version", false, "Print version and exit")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *versionFlag {
+		fmt.Fprintf(stdout, "Yoga version %s\n", meta.Version)
+		return 0
+	}
+	root, err := fsutil.ResolveRootPath(*rootFlag, defaultRoot)
+	if err != nil {
+		fmt.Fprintf(stderr, "%v\n", err)
+		return 1
+	}
+	opts := app.Options{Root: root, Crop: strings.TrimSpace(*cropFlag)}
+	if err := runApp(opts); err != nil {
+		fmt.Fprintf(stderr, "error: %v\n", err)
+		return 1
+	}
+	return 0
+}
diff --git a/cmd/yoga/main_test.go b/cmd/yoga/main_test.go
new file mode 100644
index 0000000..d06ff33
--- /dev/null
+++ b/cmd/yoga/main_test.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"yoga/internal/app"
+)
+
+func TestRunPrintsVersion(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	code := run([]string{"--version"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("expected exit code 0, got %d", code)
+	}
+	if !bytes.Contains(stdout.Bytes(), []byte("Yoga version")) {
+		t.Fatalf("expected version output, got %s", stdout.String())
+	}
+}
+
+func TestRunSuccess(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	root := t.TempDir()
+	orig := runApp
+	runApp = func(opts app.Options) error { return nil }
+	defer func() { runApp = orig }()
+	code := run([]string{"--root", root}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("expected exit code 0, got %d", code)
+	}
+}
+
+func TestRunAppError(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	root := t.TempDir()
+	orig := runApp
+	runApp = func(app.Options) error { return errors.New("boom") }
+	defer func() { runApp = orig }()
+	code := run([]string{"--root", root}, &stdout, &stderr)
+	if code != 1 {
+		t.Fatalf("expected exit code 1, got %d", code)
+	}
+	if !bytes.Contains(stderr.Bytes(), []byte("error:")) {
+		t.Fatalf("expected error output, got %s", stderr.String())
+	}
+}
+
+func TestRunDefaultRootCreated(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	orig := runApp
+	runApp = func(opts app.Options) error {
+		if _, err := os.Stat(filepath.Join(home, "Yoga")); err != nil {
+			t.Fatalf("expected default directory: %v", err)
+		}
+		return nil
+	}
+	defer func() { runApp = orig }()
+	code := run(nil, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("expected exit code 0, got %d", code)
+	}
+}
+
+func TestMainUsesExit(t *testing.T) {
+	root := t.TempDir()
+	origRun := runApp
+	origExit := exit
+	runApp = func(opts app.Options) error { return nil }
+	var code int
+	exit = func(c int) { code = c }
+	defer func() {
+		runApp = origRun
+		exit = origExit
+	}()
+	os.Args = []string{"yoga", "--root", root}
+	main()
+	if code != 0 {
+		t.Fatalf("expected exit code 0, got %d", code)
+	}
+}
diff --git a/internal/app/app.go b/internal/app/app.go
new file mode 100644
index 0000000..ca70f3c
--- /dev/null
+++ b/internal/app/app.go
@@ -0,0 +1,28 @@
+package app
+
+import (
+	"fmt"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type teaProgram interface {
+	Run() (tea.Model, error)
+}
+
+var programFactory = func(m tea.Model) teaProgram {
+	return tea.NewProgram(m, tea.WithAltScreen())
+}
+
+// Run bootstraps the Bubble Tea program with the provided options.
+func Run(opts Options) error {
+	model, err := newModel(opts)
+	if err != nil {
+		return fmt.Errorf("create model: %w", err)
+	}
+	program := programFactory(model)
+	if _, err := program.Run(); err != nil {
+		return fmt.Errorf("run program: %w", err)
+	}
+	return nil
+}
diff --git a/internal/app/app_test.go b/internal/app/app_test.go
new file mode 100644
index 0000000..ec96dbd
--- /dev/null
+++ b/internal/app/app_test.go
@@ -0,0 +1,38 @@
+package app
+
+import (
+	"errors"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type stubProgram struct {
+	err error
+}
+
+func (s stubProgram) Run() (tea.Model, error) {
+	return nil, s.err
+}
+
+func TestRunInvokesProgram(t *testing.T) {
+	t.Helper()
+	original := programFactory
+	defer func() { programFactory = original }()
+	programFactory = func(tea.Model) teaProgram { return stubProgram{} }
+	if err := Run(Options{Root: t.TempDir()}); err != nil {
+		t.Fatalf("Run returned error: %v", err)
+	}
+}
+
+func TestRunPropagatesError(t *testing.T) {
+	t.Helper()
+	original := programFactory
+	defer func() { programFactory = original }()
+	errRun := errors.New("boom")
+	programFactory = func(tea.Model) teaProgram { return stubProgram{err: errRun} }
+	err := Run(Options{Root: t.TempDir()})
+	if !errors.Is(err, errRun) {
+		t.Fatalf("expected error propagation, got %v", err)
+	}
+}
diff --git a/internal/app/duration_cache.go b/internal/app/duration_cache.go
new file mode 100644
index 0000000..43172b5
--- /dev/null
+++ b/internal/app/duration_cache.go
@@ -0,0 +1,104 @@
+package app
+
+import (
+	"encoding/json"
+	"errors"
+	"io/fs"
+	"os"
+	"sync"
+	"time"
+)
+
+type cacheEntry struct {
+	DurationSeconds float64 `json:"duration_seconds"`
+	ModTimeUnix     int64   `json:"mod_time_unix"`
+	Size            int64   `json:"size"`
+}
+
+type durationCache struct {
+	path    string
+	entries map[string]cacheEntry
+	mu      sync.Mutex
+	dirty   bool
+}
+
+func newDurationCache(path string) *durationCache {
+	return &durationCache{path: path, entries: make(map[string]cacheEntry)}
+}
+
+func loadDurationCache(path string) (*durationCache, error) {
+	cache := newDurationCache(path)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return cache, nil
+		}
+		return cache, err
+	}
+	if len(data) == 0 {
+		return cache, nil
+	}
+	if err := json.Unmarshal(data, &cache.entries); err != nil {
+		cache.entries = make(map[string]cacheEntry)
+		return cache, err
+	}
+	return cache, nil
+}
+
+func (c *durationCache) Lookup(path string, info os.FileInfo) (time.Duration, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	entry, ok := c.entries[path]
+	if !ok {
+		return 0, false
+	}
+	if entry.ModTimeUnix != info.ModTime().Unix() || entry.Size != info.Size() {
+		delete(c.entries, path)
+		c.dirty = true
+		return 0, false
+	}
+	if entry.DurationSeconds <= 0 {
+		return 0, false
+	}
+	return time.Duration(entry.DurationSeconds * float64(time.Second)), true
+}
+
+func (c *durationCache) Record(path string, info os.FileInfo, dur time.Duration) error {
+	if c == nil || dur <= 0 {
+		return nil
+	}
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.entries == nil {
+		c.entries = make(map[string]cacheEntry)
+	}
+	c.entries[path] = cacheEntry{
+		DurationSeconds: dur.Seconds(),
+		ModTimeUnix:     info.ModTime().Unix(),
+		Size:            info.Size(),
+	}
+	c.dirty = true
+	return nil
+}
+
+func (c *durationCache) Flush() error {
+	if c == nil {
+		return nil
+	}
+	c.mu.Lock()
+	if !c.dirty {
+		c.mu.Unlock()
+		return nil
+	}
+	snapshot := make(map[string]cacheEntry, len(c.entries))
+	for k, v := range c.entries {
+		snapshot[k] = v
+	}
+	c.dirty = false
+	c.mu.Unlock()
+	data, err := json.MarshalIndent(snapshot, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(c.path, data, 0o644)
+}
diff --git a/internal/app/duration_cache_test.go b/internal/app/duration_cache_test.go
new file mode 100644
index 0000000..3830277
--- /dev/null
+++ b/internal/app/duration_cache_test.go
@@ -0,0 +1,76 @@
+package app
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestDurationCacheRecordLifecycle(t *testing.T) {
+	dir := t.TempDir()
+	cachePath := filepath.Join(dir, "cache.json")
+	cache, err := loadDurationCache(cachePath)
+	if err != nil {
+		t.Fatalf("load cache: %v", err)
+	}
+	video := filepath.Join(dir, "video.mp4")
+	if err := os.WriteFile(video, []byte("x"), 0o644); err != nil {
+		t.Fatalf("write video: %v", err)
+	}
+	info, err := os.Stat(video)
+	if err != nil {
+		t.Fatalf("stat video: %v", err)
+	}
+	duration := 90 * time.Second
+	if err := cache.Record(video, info, duration); err != nil {
+		t.Fatalf("record: %v", err)
+	}
+	if err := cache.Flush(); err != nil {
+		t.Fatalf("flush: %v", err)
+	}
+	cache2, err := loadDurationCache(cachePath)
+	if err != nil {
+		t.Fatalf("reload: %v", err)
+	}
+	dur, ok := cache2.Lookup(video, info)
+	if !ok {
+		t.Fatalf("expected cached entry")
+	}
+	if dur != duration {
+		t.Fatalf("expected %v, got %v", duration, dur)
+	}
+}
+
+func TestDurationCacheInvalidatesOnChange(t *testing.T) {
+	dir := t.TempDir()
+	cache := newDurationCache(filepath.Join(dir, "cache.json"))
+	video := filepath.Join(dir, "video.mp4")
+	if err := os.WriteFile(video, []byte("x"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	info, _ := os.Stat(video)
+	_ = cache.Record(video, info, 30*time.Second)
+	if err := os.WriteFile(video, []byte("xx"), 0o644); err != nil {
+		t.Fatalf("rewrite: %v", err)
+	}
+	info, _ = os.Stat(video)
+	if dur, ok := cache.Lookup(video, info); ok || dur != 0 {
+		t.Fatalf("expected cache miss after change")
+	}
+}
+
+func TestLoadDurationCacheInvalidJSON(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "cache.json")
+	if err := os.WriteFile(path, []byte("not json"), 0o644); err != nil {
+		t.Fatalf("write cache: %v", err)
+	}
+	cache, err := loadDurationCache(path)
+	if err == nil {
+		t.Fatalf("expected error for invalid json")
+	}
+	if len(cache.entries) != 0 {
+		t.Fatalf("expected cache to reset entries")
+	}
+}
diff --git a/internal/app/filters.go b/internal/app/filters.go
new file mode 100644
index 0000000..691be41
--- /dev/null
+++ b/internal/app/filters.go
@@ -0,0 +1,146 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type filterState struct {
+	name       string
+	minEnabled bool
+	minMinutes int
+	maxEnabled bool
+	maxMinutes int
+}
+
+type filterInputs struct {
+	fields []textinput.Model
+	focus  int
+}
+
+func (m *model) applyFilterInputs() error {
+	name := strings.TrimSpace(m.inputs.fields[0].Value())
+	minText := strings.TrimSpace(m.inputs.fields[1].Value())
+	maxText := strings.TrimSpace(m.inputs.fields[2].Value())
+
+	filters := filterState{name: name}
+	if err := populateMinFilter(&filters, minText); err != nil {
+		return err
+	}
+	if err := populateMaxFilter(&filters, maxText); err != nil {
+		return err
+	}
+	if filters.minEnabled && filters.maxEnabled && filters.minMinutes > filters.maxMinutes {
+		return errors.New("min minutes cannot exceed max minutes")
+	}
+	m.filters = filters
+	return nil
+}
+
+func populateMinFilter(dst *filterState, value string) error {
+	if value == "" {
+		return nil
+	}
+	minutes, err := strconv.Atoi(value)
+	if err != nil {
+		return fmt.Errorf("invalid min minutes: %q", value)
+	}
+	if minutes < 0 {
+		return errors.New("min minutes must be positive")
+	}
+	dst.minEnabled = true
+	dst.minMinutes = minutes
+	return nil
+}
+
+func populateMaxFilter(dst *filterState, value string) error {
+	if value == "" {
+		return nil
+	}
+	minutes, err := strconv.Atoi(value)
+	if err != nil {
+		return fmt.Errorf("invalid max minutes: %q", value)
+	}
+	if minutes < 0 {
+		return errors.New("max minutes must be positive")
+	}
+	dst.maxEnabled = true
+	dst.maxMinutes = minutes
+	return nil
+}
+
+func (m *model) resetFilters() {
+	m.filters = filterState{}
+	for i := range m.inputs.fields {
+		m.inputs.fields[i].SetValue("")
+	}
+}
+
+func (m *model) updateFilterInputs(msg tea.Msg) (filterInputs, tea.Cmd) {
+	inputs := m.inputs
+	var cmds []tea.Cmd
+	for i := range inputs.fields {
+		var cmd tea.Cmd
+		inputs.fields[i], cmd = inputs.fields[i].Update(msg)
+		cmds = append(cmds, cmd)
+	}
+	return inputs, tea.Batch(cmds...)
+}
+
+func (m model) describeFilters() string {
+	parts := []string{}
+	if m.filters.name != "" {
+		parts = append(parts, fmt.Sprintf("name contains %q", m.filters.name))
+	}
+	if m.filters.minEnabled {
+		parts = append(parts, fmt.Sprintf(">=%d min", m.filters.minMinutes))
+	}
+	if m.filters.maxEnabled {
+		parts = append(parts, fmt.Sprintf("<=%d min", m.filters.maxMinutes))
+	}
+	if len(parts) == 0 {
+		return "(none)"
+	}
+	return strings.Join(parts, ", ")
+}
+
+func (m *model) passesFilters(v video) bool {
+	if m.filters.name != "" && !strings.Contains(strings.ToLower(v.Name), strings.ToLower(m.filters.name)) {
+		return false
+	}
+	durMinutes := int(v.Duration.Round(time.Minute) / time.Minute)
+	if m.filters.minEnabled && (v.Duration == 0 || durMinutes < m.filters.minMinutes) {
+		return false
+	}
+	if m.filters.maxEnabled && (v.Duration == 0 || durMinutes > m.filters.maxMinutes) {
+		return false
+	}
+	return true
+}
+
+func (m *model) renderFilterModal() string {
+	var b strings.Builder
+	b.WriteString("Filter videos\n")
+	b.WriteString("(Enter to apply, Esc to cancel)\n\n")
+	labels := []string{"Name contains:", "Min length (minutes):", "Max length (minutes):"}
+	for i, field := range m.inputs.fields {
+		line := fmt.Sprintf("%s %s", labels[i], field.View())
+		if i == m.inputs.focus {
+			line = highlightStyle.Render(line)
+		}
+		b.WriteString(line)
+		b.WriteString("\n")
+	}
+	if m.filters.minEnabled || m.filters.maxEnabled || m.filters.name != "" {
+		b.WriteString("\nCurrent filter: ")
+		b.WriteString(m.describeFilters())
+		b.WriteString("\n")
+	}
+	return filterStyle.Render(b.String())
+}
diff --git a/internal/app/filters_test.go b/internal/app/filters_test.go
new file mode 100644
index 0000000..10eed13
--- /dev/null
+++ b/internal/app/filters_test.go
@@ -0,0 +1,35 @@
+package app
+
+import "testing"
+
+func TestPopulateMinFilterErrors(t *testing.T) {
+	var state filterState
+	if err := populateMinFilter(&state, "-1"); err == nil {
+		t.Fatal("expected error for negative minutes")
+	}
+	if err := populateMinFilter(&state, "abc"); err == nil {
+		t.Fatal("expected error for invalid integer")
+	}
+	if err := populateMinFilter(&state, "10"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !state.minEnabled || state.minMinutes != 10 {
+		t.Fatalf("expected state updated, got %+v", state)
+	}
+}
+
+func TestPopulateMaxFilterErrors(t *testing.T) {
+	var state filterState
+	if err := populateMaxFilter(&state, "-1"); err == nil {
+		t.Fatal("expected error for negative minutes")
+	}
+	if err := populateMaxFilter(&state, "abc"); err == nil {
+		t.Fatal("expected error for invalid integer")
+	}
+	if err := populateMaxFilter(&state, "20"); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !state.maxEnabled || state.maxMinutes != 20 {
+		t.Fatalf("expected state updated, got %+v", state)
+	}
+}
diff --git a/internal/app/load_progress.go b/internal/app/load_progress.go
new file mode 100644
index 0000000..38679fa
--- /dev/null
+++ b/internal/app/load_progress.go
@@ -0,0 +1,57 @@
+package app
+
+import "sync"
+
+type loadProgress struct {
+	mu        sync.Mutex
+	total     int
+	processed int
+	done      bool
+}
+
+func (p *loadProgress) Reset() {
+	if p == nil {
+		return
+	}
+	p.mu.Lock()
+	p.total = 0
+	p.processed = 0
+	p.done = false
+	p.mu.Unlock()
+}
+
+func (p *loadProgress) SetTotal(total int) {
+	if p == nil {
+		return
+	}
+	p.mu.Lock()
+	p.total = total
+	p.mu.Unlock()
+}
+
+func (p *loadProgress) Increment() {
+	if p == nil {
+		return
+	}
+	p.mu.Lock()
+	p.processed++
+	p.mu.Unlock()
+}
+
+func (p *loadProgress) MarkDone() {
+	if p == nil {
+		return
+	}
+	p.mu.Lock()
+	p.done = true
+	p.mu.Unlock()
+}
+
+func (p *loadProgress) Snapshot() (processed, total int, done bool) {
+	if p == nil {
+		return 0, 0, true
+	}
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	return p.processed, p.total, p.done
+}
diff --git a/internal/app/load_progress_test.go b/internal/app/load_progress_test.go
new file mode 100644
index 0000000..c46636d
--- /dev/null
+++ b/internal/app/load_progress_test.go
@@ -0,0 +1,25 @@
+package app
+
+import "testing"
+
+func TestLoadProgressLifecycle(t *testing.T) {
+	var progress loadProgress
+	progress.SetTotal(5)
+	for i := 0; i < 3; i++ {
+		progress.Increment()
+	}
+	processed, total, done := progress.Snapshot()
+	if processed != 3 || total != 5 || done {
+		t.Fatalf("unexpected snapshot %d/%d done=%v", processed, total, done)
+	}
+	progress.MarkDone()
+	_, _, done = progress.Snapshot()
+	if !done {
+		t.Fatal("expected done")
+	}
+	progress.Reset()
+	processed, total, done = progress.Snapshot()
+	if processed != 0 || total != 0 || done {
+		t.Fatalf("expected reset to zero, got %d/%d done=%v", processed, total, done)
+	}
+}
diff --git a/internal/app/loader.go b/internal/app/loader.go
new file mode 100644
index 0000000..37c8c94
--- /dev/null
+++ b/internal/app/loader.go
@@ -0,0 +1,241 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func loadVideosCmd(root, cachePath string, progress *loadProgress) tea.Cmd {
+	return func() tea.Msg {
+		cache, cacheErr := loadDurationCache(cachePath)
+		videos, pending, err := loadVideos(root, cache, progress)
+		if progress != nil {
+			progress.MarkDone()
+		}
+		return videosLoadedMsg{videos: videos, err: err, cacheErr: cacheErr, pending: pending, cache: cache}
+	}
+}
+
+func progressTickerCmd(progress *loadProgress) tea.Cmd {
+	if progress == nil {
+		return nil
+	}
+	return tea.Tick(200*time.Millisecond, func(time.Time) tea.Msg {
+		processed, total, done := progress.Snapshot()
+		return progressUpdateMsg{processed: processed, total: total, done: done}
+	})
+}
+
+func loadVideos(root string, cache *durationCache, progress *loadProgress) ([]video, []string, error) {
+	paths, err := collectVideoPaths(root)
+	if err != nil {
+		return nil, nil, err
+	}
+	if progress != nil {
+		progress.SetTotal(len(paths))
+	}
+	videos := make([]video, 0, len(paths))
+	pending := make([]string, 0)
+	for _, path := range paths {
+		info, statErr := os.Stat(path)
+		if statErr != nil {
+			videos = append(videos, video{Name: filepath.Base(path), Path: path, Err: statErr})
+			increment(progress)
+			continue
+		}
+		dur := cachedDuration(cache, path, info)
+		if dur == 0 {
+			pending = append(pending, path)
+		}
+		videos = append(videos, video{
+			Name:     filepath.Base(path),
+			Path:     path,
+			Duration: dur,
+			ModTime:  info.ModTime(),
+			Size:     info.Size(),
+		})
+		increment(progress)
+	}
+	return videos, pending, nil
+}
+
+func increment(progress *loadProgress) {
+	if progress != nil {
+		progress.Increment()
+	}
+}
+
+func cachedDuration(cache *durationCache, path string, info os.FileInfo) time.Duration {
+	if cache == nil {
+		return 0
+	}
+	dur, ok := cache.Lookup(path, info)
+	if !ok {
+		return 0
+	}
+	return dur
+}
+
+func collectVideoPaths(root string) ([]string, error) {
+	info, err := os.Stat(root)
+	if err != nil {
+		return nil, err
+	}
+	if !info.IsDir() {
+		if isVideo(root) {
+			return []string{root}, nil
+		}
+		return nil, nil
+	}
+	visited := make(map[string]struct{})
+	var paths []string
+	if err := traverseVideoPaths(root, root, visited, &paths); err != nil {
+		return nil, err
+	}
+	sort.Strings(paths)
+	return paths, nil
+}
+
+func traverseVideoPaths(displayPath, realPath string, visited map[string]struct{}, acc *[]string) error {
+	resolved, err := filepath.EvalSymlinks(realPath)
+	if err != nil {
+		resolved = realPath
+	}
+	resolved = filepath.Clean(resolved)
+	if _, seen := visited[resolved]; seen {
+		return nil
+	}
+	visited[resolved] = struct{}{}
+
+	entries, err := os.ReadDir(resolved)
+	if err != nil {
+		return err
+	}
+	for _, entry := range entries {
+		displayChild := filepath.Join(displayPath, entry.Name())
+		realChild := filepath.Join(resolved, entry.Name())
+		mode := entry.Type()
+		var info os.FileInfo
+		if mode == fs.FileMode(0) {
+			info, err = entry.Info()
+			if err != nil {
+				return err
+			}
+			mode = info.Mode()
+		}
+		if mode&os.ModeSymlink != 0 {
+			if err := handleSymlink(displayChild, realChild, visited, acc); err != nil {
+				return err
+			}
+			continue
+		}
+		if mode.IsDir() {
+			if err := traverseVideoPaths(displayChild, realChild, visited, acc); err != nil {
+				return err
+			}
+			continue
+		}
+		if isVideo(displayChild) {
+			*acc = append(*acc, displayChild)
+		}
+	}
+	return nil
+}
+
+func handleSymlink(displayChild, realChild string, visited map[string]struct{}, acc *[]string) error {
+	targetPath, err := filepath.EvalSymlinks(realChild)
+	if err != nil {
+		return recordIfVideo(displayChild, acc)
+	}
+	targetInfo, err := os.Stat(targetPath)
+	if err != nil {
+		return recordIfVideo(displayChild, acc)
+	}
+	if targetInfo.IsDir() {
+		return traverseVideoPaths(displayChild, targetPath, visited, acc)
+	}
+	if isVideo(displayChild) || isVideo(targetPath) {
+		*acc = append(*acc, displayChild)
+	}
+	return nil
+}
+
+func recordIfVideo(path string, acc *[]string) error {
+	if isVideo(path) {
+		*acc = append(*acc, path)
+	}
+	return nil
+}
+
+func probeDurationsCmd(path string, cache *durationCache) tea.Cmd {
+	return func() tea.Msg {
+		dur, err := probeDuration(path)
+		if err == nil && cache != nil {
+			if info, statErr := os.Stat(path); statErr == nil {
+				_ = cache.Record(path, info, dur)
+			}
+		}
+		return durationUpdateMsg{path: path, duration: dur, err: err}
+	}
+}
+
+func probeDuration(path string) (time.Duration, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path)
+	out, err := cmd.Output()
+	if err != nil {
+		return 0, err
+	}
+	raw := strings.TrimSpace(string(out))
+	if raw == "" {
+		return 0, errors.New("empty duration")
+	}
+	seconds, err := strconv.ParseFloat(raw, 64)
+	if err != nil {
+		return 0, err
+	}
+	return time.Duration(seconds * float64(time.Second)), nil
+}
+
+func playVideoCmd(path, crop string) tea.Cmd {
+	return func() tea.Msg {
+		args := buildVLCArgs(path, crop)
+		cmd := exec.Command("vlc", args...)
+		if err := cmd.Start(); err != nil {
+			return playVideoMsg{path: path, err: err}
+		}
+		go func() { _ = cmd.Wait() }()
+		return playVideoMsg{path: path}
+	}
+}
+
+func buildVLCArgs(path, crop string) []string {
+	args := []string{}
+	if crop != "" {
+		args = append(args, "--crop", crop)
+	}
+	return append(args, path)
+}
+
+func isVideo(path string) bool {
+	ext := strings.ToLower(filepath.Ext(path))
+	_, ok := videoExtensions[ext]
+	return ok
+}
+
+// CollectVideoPathsForTest exposes collectVideoPaths for unit testing.
+func CollectVideoPathsForTest(root string) ([]string, error) {
+	return collectVideoPaths(root)
+}
diff --git a/internal/app/loader_test.go b/internal/app/loader_test.go
new file mode 100644
index 0000000..538bca0
--- /dev/null
+++ b/internal/app/loader_test.go
@@ -0,0 +1,162 @@
+package app
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+)
+
+func TestCollectVideoPathsDetectsMP4(t *testing.T) {
+	dir := t.TempDir()
+	lower := filepath.Join(dir, "video.mp4")
+	upper := filepath.Join(dir, "UPPER.MP4")
+	for _, path := range []string{lower, upper} {
+		if err := os.WriteFile(path, []byte("dummy"), 0o644); err != nil {
+			t.Fatalf("write %s: %v", path, err)
+		}
+	}
+	paths, err := CollectVideoPathsForTest(dir)
+	if err != nil {
+		t.Fatalf("collect paths: %v", err)
+	}
+	if len(paths) != 2 {
+		t.Fatalf("expected 2 paths, got %d", len(paths))
+	}
+	want := map[string]struct{}{lower: {}, upper: {}}
+	for _, got := range paths {
+		if _, ok := want[got]; !ok {
+			t.Fatalf("unexpected path %s", got)
+		}
+	}
+}
+
+func TestCollectVideoPathsFollowsSymlink(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("symlink permissions vary on Windows")
+	}
+	root := t.TempDir()
+	storage := t.TempDir()
+	video := filepath.Join(storage, "movie.mp4")
+	if err := os.WriteFile(video, []byte("dummy"), 0o644); err != nil {
+		t.Fatalf("write video: %v", err)
+	}
+	link := filepath.Join(root, "videos")
+	if err := os.Symlink(storage, link); err != nil {
+		t.Skipf("symlink not supported: %v", err)
+	}
+	paths, err := CollectVideoPathsForTest(root)
+	if err != nil {
+		t.Fatalf("collect paths: %v", err)
+	}
+	expected := filepath.Join(link, "movie.mp4")
+	if len(paths) != 1 || paths[0] != expected {
+		t.Fatalf("expected %s, got %v", expected, paths)
+	}
+}
+
+func TestLoadVideosWithCache(t *testing.T) {
+	dir := t.TempDir()
+	video := filepath.Join(dir, "video.mp4")
+	if err := os.WriteFile(video, []byte("dummy"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	cache := newDurationCache(filepath.Join(dir, "cache.json"))
+	info, err := os.Stat(video)
+	if err != nil {
+		t.Fatalf("stat: %v", err)
+	}
+	_ = cache.Record(video, info, time.Minute)
+	progress := &loadProgress{}
+	progress.Reset()
+	videos, pending, err := loadVideos(dir, cache, progress)
+	if err != nil {
+		t.Fatalf("loadVideos: %v", err)
+	}
+	if len(videos) != 1 || len(pending) != 0 {
+		t.Fatalf("expected cached video without pending: videos=%d pending=%d", len(videos), len(pending))
+	}
+	if videos[0].Duration != time.Minute {
+		t.Fatalf("expected cached duration")
+	}
+}
+
+func TestProbeDurationsCmdHandlesMissingBinary(t *testing.T) {
+	cmd := probeDurationsCmd("/no/such/file.mp4", nil)
+	msg := cmd()
+	update := msg.(durationUpdateMsg)
+	if update.err == nil {
+		t.Fatalf("expected error from ffprobe")
+	}
+}
+
+func TestProbeDurationSuccess(t *testing.T) {
+	dir := t.TempDir()
+	script := filepath.Join(dir, "ffprobe")
+	if err := os.WriteFile(script, []byte("#!/bin/sh\necho 5\n"), 0o755); err != nil {
+		t.Fatalf("write script: %v", err)
+	}
+	oldPath := os.Getenv("PATH")
+	t.Setenv("PATH", dir+":"+oldPath)
+	dur, err := probeDuration("dummy.mp4")
+	if err != nil {
+		t.Fatalf("probeDuration: %v", err)
+	}
+	if dur != 5*time.Second {
+		t.Fatalf("expected 5s duration, got %v", dur)
+	}
+}
+
+func TestPlayVideoCmdMissingBinary(t *testing.T) {
+	cmd := playVideoCmd("/no/such/file.mp4", "")
+	msg := cmd()
+	result := msg.(playVideoMsg)
+	if result.path != "/no/such/file.mp4" {
+		t.Fatalf("unexpected path %s", result.path)
+	}
+}
+
+func TestRecordIfVideo(t *testing.T) {
+	var acc []string
+	if err := recordIfVideo("test.mp4", &acc); err != nil {
+		t.Fatalf("recordIfVideo: %v", err)
+	}
+	if len(acc) != 1 {
+		t.Fatalf("expected video recorded")
+	}
+}
+
+func TestHandleSymlinkBrokenVideo(t *testing.T) {
+	dir := t.TempDir()
+	symlink := filepath.Join(dir, "clip.mp4")
+	target := filepath.Join(dir, "missing.mp4")
+	if err := os.Symlink(target, symlink); err != nil {
+		t.Skipf("symlink unsupported: %v", err)
+	}
+	var acc []string
+	if err := handleSymlink(symlink, symlink, map[string]struct{}{}, &acc); err != nil {
+		t.Fatalf("handleSymlink: %v", err)
+	}
+	if len(acc) != 1 {
+		t.Fatalf("expected symlink video recorded")
+	}
+}
+
+func TestLoadVideosHandlesStatError(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("symlink permissions vary on Windows")
+	}
+	dir := t.TempDir()
+	broken := filepath.Join(dir, "broken.mp4")
+	if err := os.Symlink(filepath.Join(dir, "missing.mp4"), broken); err != nil {
+		t.Skipf("symlink unsupported: %v", err)
+	}
+	videos, _, err := loadVideos(dir, nil, nil)
+	if err != nil {
+		t.Fatalf("loadVideos: %v", err)
+	}
+	if len(videos) != 1 || videos[0].Err == nil {
+		t.Fatalf("expected stat error recorded, got %+v", videos)
+	}
+}
diff --git a/internal/app/messages.go b/internal/app/messages.go
new file mode 100644
index 0000000..a905263
--- /dev/null
+++ b/internal/app/messages.go
@@ -0,0 +1,28 @@
+package app
+
+import "time"
+
+type videosLoadedMsg struct {
+	videos   []video
+	err      error
+	cacheErr error
+	pending  []string
+	cache    *durationCache
+}
+
+type playVideoMsg struct {
+	path string
+	err  error
+}
+
+type progressUpdateMsg struct {
+	processed int
+	total     int
+	done      bool
+}
+
+type durationUpdateMsg struct {
+	path     string
+	duration time.Duration
+	err      error
+}
diff --git a/internal/app/model.go b/internal/app/model.go
new file mode 100644
index 0000000..8cdcddc
--- /dev/null
+++ b/internal/app/model.go
@@ -0,0 +1,198 @@
+package app
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/table"
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type sortField int
+
+const (
+	sortByName sortField = iota
+	sortByDuration
+	sortByAge
+)
+
+type model struct {
+	table            table.Model
+	videos           []video
+	filtered         []video
+	filters          filterState
+	inputs           filterInputs
+	showFilters      bool
+	sortField        sortField
+	sortAscending    bool
+	statusMessage    string
+	loading          bool
+	err              error
+	root             string
+	progress         *loadProgress
+	cachePath        string
+	cache            *durationCache
+	pendingDurations []string
+	durationTotal    int
+	durationDone     int
+	durationInFlight int
+	cropValue        string
+	cropEnabled      bool
+}
+
+func newModel(opts Options) (model, error) {
+	tbl := buildTable()
+	inputs := buildFilterInputs()
+	inputs.fields[0].Focus()
+
+	progress := &loadProgress{}
+	cachePath := filepath.Join(opts.Root, ".video_duration_cache.json")
+
+	return model{
+		table:         tbl,
+		inputs:        inputs,
+		sortField:     sortByName,
+		sortAscending: true,
+		statusMessage: "Scanning for videos...",
+		loading:       true,
+		root:          opts.Root,
+		progress:      progress,
+		cachePath:     cachePath,
+		cropValue:     opts.Crop,
+		cropEnabled:   opts.Crop != "",
+	}, nil
+}
+
+func buildTable() table.Model {
+	columns := []table.Column{
+		{Title: headerStyle.Render("Name"), Width: 50},
+		{Title: headerStyle.Render("Duration"), Width: 12},
+		{Title: headerStyle.Render("Age"), Width: 14},
+		{Title: headerStyle.Render("Path"), Width: 40},
+	}
+	tbl := table.New(
+		table.WithColumns(columns),
+		table.WithFocused(true),
+		table.WithHeight(15),
+	)
+	tbl.SetStyles(table.DefaultStyles())
+	return tbl
+}
+
+func buildFilterInputs() filterInputs {
+	nameInput := textinput.New()
+	nameInput.Placeholder = "substring"
+	nameInput.Prompt = "Name: "
+	nameInput.CharLimit = 256
+
+	minInput := textinput.New()
+	minInput.Placeholder = "min minutes"
+	minInput.Prompt = "Min minutes: "
+	minInput.CharLimit = 4
+
+	maxInput := textinput.New()
+	maxInput.Placeholder = "max minutes"
+	maxInput.Prompt = "Max minutes: "
+	maxInput.CharLimit = 4
+
+	return filterInputs{
+		fields: []textinput.Model{nameInput, minInput, maxInput},
+		focus:  0,
+	}
+}
+
+func (m model) Init() tea.Cmd {
+	if m.progress != nil {
+		m.progress.Reset()
+	}
+	loadCmd := loadVideosCmd(m.root, m.cachePath, m.progress)
+	if m.progress != nil {
+		return tea.Batch(loadCmd, progressTickerCmd(m.progress))
+	}
+	return loadCmd
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch typed := msg.(type) {
+	case tea.KeyMsg:
+		return m.handleKeyMsg(typed)
+	case progressUpdateMsg:
+		return m.handleProgressUpdate(typed)
+	case durationUpdateMsg:
+		return m.handleDurationUpdate(typed)
+	case videosLoadedMsg:
+		return m.handleVideosLoaded(typed)
+	case playVideoMsg:
+		return m.handlePlayVideo(typed), nil
+	default:
+		return m.updateTable(msg)
+	}
+}
+
+func (m model) View() string {
+	if m.loading {
+		return statusStyle.Render("Loading videos, please wait...")
+	}
+	body := m.renderBody()
+	if m.showFilters {
+		return body + "\n\n" + m.renderFilterModal()
+	}
+	return body
+}
+
+func (m model) renderBody() string {
+	helpLines := []string{
+		"↑/↓ navigate  •  enter play  •  s sort  •  / filter  •  c copy path  •  q quit",
+	}
+	info := statusStyle.Render(m.statusMessage)
+	progressLine := m.renderProgressLine()
+	content := tableStyle.Render(m.table.View())
+	help := strings.Join(helpLines, "\n")
+	parts := []string{content}
+	if progressLine != "" {
+		parts = append(parts, progressLine)
+	}
+	parts = append(parts, info, help)
+	return strings.Join(parts, "\n")
+}
+
+func (m model) renderProgressLine() string {
+	if m.durationTotal == 0 {
+		return ""
+	}
+	bar := renderProgressBar(m.durationDone, m.durationTotal, 24)
+	return statusStyle.Render(fmt.Sprintf("Duration scan %s %d/%d", bar, m.durationDone, m.durationTotal))
+}
+
+func (m model) updateTable(msg tea.Msg) (tea.Model, tea.Cmd) {
+	tbl, cmd := m.table.Update(msg)
+	m.table = tbl
+	return m, cmd
+}
+
+func (m model) handlePlayVideo(msg playVideoMsg) model {
+	if msg.err != nil {
+		m.statusMessage = fmt.Sprintf("Failed to launch VLC: %v", msg.err)
+		return m
+	}
+	m.statusMessage = fmt.Sprintf("Playing via VLC: %s", trimPath(msg.path))
+	return m
+}
+
+func (m model) handleProgressUpdate(msg progressUpdateMsg) (tea.Model, tea.Cmd) {
+	if !m.loading {
+		return m, nil
+	}
+	if msg.total == 0 && msg.done {
+		m.statusMessage = "No videos found"
+		return m, nil
+	}
+	if msg.done {
+		m.statusMessage = fmt.Sprintf("Loaded %d videos", msg.total)
+		return m, nil
+	}
+	m.statusMessage = fmt.Sprintf("Loading videos %d/%d...", msg.processed, msg.total)
+	return m, progressTickerCmd(m.progress)
+}
diff --git a/internal/app/model_durations.go b/internal/app/model_durations.go
new file mode 100644
index 0000000..b92e816
--- /dev/null
+++ b/internal/app/model_durations.go
@@ -0,0 +1,181 @@
+package app
+
+import (
+	"fmt"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) handleDurationUpdate(msg durationUpdateMsg) (tea.Model, tea.Cmd) {
+	if msg.path != "" {
+		m.updateVideoDuration(msg.path, msg.duration, msg.err)
+		m.durationDone++
+		m.updateStatusForDuration(msg)
+	}
+	if m.durationInFlight > 0 {
+		m.durationInFlight--
+	}
+	selectedPath := m.currentSelectionPath()
+	m.applyFiltersAndSort()
+	m.restoreSelection(selectedPath)
+	if m.allDurationsResolved() {
+		m.onDurationsComplete()
+		return m, nil
+	}
+	cmd := m.dequeueDurationCmd()
+	return m, cmd
+}
+
+func (m *model) updateStatusForDuration(msg durationUpdateMsg) {
+	if msg.err != nil {
+		m.statusMessage = fmt.Sprintf("Duration error for %s: %v", filepath.Base(msg.path), msg.err)
+		return
+	}
+	if m.durationTotal > 0 {
+		m.statusMessage = fmt.Sprintf("Probing durations %d/%d...", m.durationDone, m.durationTotal)
+	}
+}
+
+func (m model) currentSelectionPath() string {
+	idx := m.table.Cursor()
+	if idx < 0 || idx >= len(m.filtered) {
+		return ""
+	}
+	return m.filtered[idx].Path
+}
+
+func (m *model) restoreSelection(path string) {
+	if path == "" {
+		return
+	}
+	for i, video := range m.filtered {
+		if video.Path == path {
+			m.table.SetCursor(i)
+			return
+		}
+	}
+}
+
+func (m *model) updateVideoDuration(path string, dur time.Duration, err error) {
+	for i := range m.videos {
+		if m.videos[i].Path != path {
+			continue
+		}
+		m.videos[i].Duration = dur
+		m.videos[i].Err = err
+		return
+	}
+}
+
+func (m model) allDurationsResolved() bool {
+	return m.durationDone >= m.durationTotal && m.durationInFlight == 0
+}
+
+func (m *model) onDurationsComplete() {
+	if m.cache != nil {
+		if err := m.cache.Flush(); err != nil {
+			m.statusMessage = fmt.Sprintf("Duration cache flush error: %v", err)
+		} else {
+			m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
+		}
+		m.resetDurationState()
+		return
+	}
+	m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
+	m.resetDurationState()
+}
+
+func (m *model) resetDurationState() {
+	m.pendingDurations = nil
+	m.durationTotal = 0
+	m.durationDone = 0
+	m.durationInFlight = 0
+}
+
+func (m *model) dequeueDurationCmd() tea.Cmd {
+	if len(m.pendingDurations) == 0 {
+		return nil
+	}
+	path := m.pendingDurations[0]
+	m.pendingDurations = m.pendingDurations[1:]
+	m.durationInFlight++
+	return probeDurationsCmd(path, m.cache)
+}
+
+func (m *model) startDurationWorkers() tea.Cmd {
+	if len(m.pendingDurations) == 0 {
+		return nil
+	}
+	workers := runtime.NumCPU()
+	if workers < 1 {
+		workers = 1
+	}
+	if workers > 6 {
+		workers = 6
+	}
+	if workers > len(m.pendingDurations) {
+		workers = len(m.pendingDurations)
+	}
+	cmds := make([]tea.Cmd, 0, workers)
+	for i := 0; i < workers; i++ {
+		cmd := m.dequeueDurationCmd()
+		if cmd != nil {
+			cmds = append(cmds, cmd)
+		}
+	}
+	if len(cmds) == 0 {
+		return nil
+	}
+	return tea.Batch(cmds...)
+}
+
+func (m model) activeCrop() string {
+	if m.cropEnabled && m.cropValue != "" {
+		return m.cropValue
+	}
+	return ""
+}
+
+func (m model) handleVideosLoaded(msg videosLoadedMsg) (tea.Model, tea.Cmd) {
+	m.loading = false
+	if msg.err != nil {
+		m.err = msg.err
+		m.statusMessage = fmt.Sprintf("error: %v", msg.err)
+	}
+	m.videos = msg.videos
+	m.cache = msg.cache
+	m.pendingDurations = msg.pending
+	m.durationTotal = len(msg.pending)
+	m.durationDone = 0
+	m.applyFiltersAndSort()
+	m.updateStatusAfterLoad(msg)
+	m.durationInFlight = 0
+	if len(msg.pending) == 0 {
+		return m, nil
+	}
+	cmd := m.startDurationWorkers()
+	return m, cmd
+}
+
+func (m *model) updateStatusAfterLoad(msg videosLoadedMsg) {
+	if len(m.filtered) == 0 {
+		m.statusMessage = "No videos found"
+		return
+	}
+	if len(msg.pending) > 0 {
+		if msg.cacheErr != nil {
+			m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v), probing durations...", len(m.filtered), msg.cacheErr)
+			return
+		}
+		m.statusMessage = fmt.Sprintf("Loaded %d videos, probing durations...", len(m.filtered))
+		return
+	}
+	if msg.cacheErr != nil {
+		m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v)", len(m.filtered), msg.cacheErr)
+		return
+	}
+	m.statusMessage = fmt.Sprintf("Loaded %d videos", len(m.filtered))
+}
diff --git a/internal/app/model_keys.go b/internal/app/model_keys.go
new file mode 100644
index 0000000..d02cf46
--- /dev/null
+++ b/internal/app/model_keys.go
@@ -0,0 +1,138 @@
+package app
+
+import (
+	"fmt"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if cmd, handled := globalKeyHandler(msg); handled {
+		return m, cmd
+	}
+	if m.loading {
+		return m, nil
+	}
+	if m.showFilters {
+		return m.handleFilterKey(msg)
+	}
+	return m.handleTableKey(msg)
+}
+
+func globalKeyHandler(msg tea.KeyMsg) (tea.Cmd, bool) {
+	switch msg.String() {
+	case "ctrl+c", "q":
+		return tea.Quit, true
+	default:
+		return nil, false
+	}
+}
+
+func (m model) handleFilterKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc":
+		m.showFilters = false
+		m.statusMessage = "Filter closed"
+		return m, nil
+	case "enter":
+		cmd := m.applyFiltersFromInputs()
+		return m, cmd
+	case "tab":
+		m.inputs.focus = (m.inputs.focus + 1) % len(m.inputs.fields)
+	case "shift+tab":
+		m.inputs.focus = (m.inputs.focus - 1 + len(m.inputs.fields)) % len(m.inputs.fields)
+	}
+	m.syncFilterFocus()
+	updated, cmd := m.updateFilterInputs(msg)
+	m.inputs = updated
+	return m, cmd
+}
+
+func (m *model) applyFiltersFromInputs() tea.Cmd {
+	if err := m.applyFilterInputs(); err != nil {
+		m.statusMessage = err.Error()
+		return nil
+	}
+	m.showFilters = false
+	m.applyFiltersAndSort()
+	m.statusMessage = fmt.Sprintf("Filters applied (%d videos)", len(m.filtered))
+	return nil
+}
+
+func (m *model) syncFilterFocus() {
+	for i := range m.inputs.fields {
+		if i == m.inputs.focus {
+			m.inputs.fields[i].Focus()
+			continue
+		}
+		m.inputs.fields[i].Blur()
+	}
+}
+
+func (m model) handleTableKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "/", "f":
+		return m.openFilters()
+	case "enter":
+		return m.playSelection()
+	case "n":
+		return m.sortAndReport(sortByName)
+	case "l":
+		return m.sortAndReport(sortByDuration)
+	case "a":
+		return m.sortAndReport(sortByAge)
+	case "c":
+		return m.toggleCrop()
+	case "r":
+		return m.resetFilterState()
+	default:
+		return m.updateTable(msg)
+	}
+}
+
+func (m model) openFilters() (tea.Model, tea.Cmd) {
+	m.showFilters = true
+	m.statusMessage = "Editing filters"
+	return m, nil
+}
+
+func (m model) playSelection() (tea.Model, tea.Cmd) {
+	if len(m.filtered) == 0 {
+		return m, nil
+	}
+	idx := m.table.Cursor()
+	if idx < 0 || idx >= len(m.filtered) {
+		return m, nil
+	}
+	video := m.filtered[idx]
+	m.statusMessage = fmt.Sprintf("Launching VLC: %s", video.Name)
+	return m, playVideoCmd(video.Path, m.activeCrop())
+}
+
+func (m model) sortAndReport(field sortField) (tea.Model, tea.Cmd) {
+	m.toggleSort(field)
+	m.applyFiltersAndSort()
+	m.statusMessage = fmt.Sprintf("Sorted %d videos", len(m.filtered))
+	return m, nil
+}
+
+func (m model) toggleCrop() (tea.Model, tea.Cmd) {
+	if m.cropValue == "" {
+		m.statusMessage = "No crop value set (start with --crop)"
+		return m, nil
+	}
+	m.cropEnabled = !m.cropEnabled
+	if m.cropEnabled {
+		m.statusMessage = fmt.Sprintf("Crop enabled (%s)", m.cropValue)
+		return m, nil
+	}
+	m.statusMessage = "Crop disabled"
+	return m, nil
+}
+
+func (m model) resetFilterState() (tea.Model, tea.Cmd) {
+	m.resetFilters()
+	m.applyFiltersAndSort()
+	m.statusMessage = fmt.Sprintf("Filters cleared (%d videos)", len(m.filtered))
+	return m, nil
+}
diff --git a/internal/app/model_sort.go b/internal/app/model_sort.go
new file mode 100644
index 0000000..e3120c4
--- /dev/null
+++ b/internal/app/model_sort.go
@@ -0,0 +1,58 @@
+package app
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/table"
+)
+
+func (m *model) toggleSort(target sortField) {
+	if m.sortField == target {
+		m.sortAscending = !m.sortAscending
+		return
+	}
+	m.sortField = target
+	m.sortAscending = true
+}
+
+func (m *model) applyFiltersAndSort() {
+	filtered := make([]video, 0, len(m.videos))
+	for _, v := range m.videos {
+		if m.passesFilters(v) {
+			filtered = append(filtered, v)
+		}
+	}
+	sort.Slice(filtered, func(i, j int) bool {
+		return m.less(filtered[i], filtered[j])
+	})
+	m.filtered = filtered
+	m.updateTableRows()
+}
+
+func (m *model) less(a, b video) bool {
+	var less bool
+	switch m.sortField {
+	case sortByName:
+		less = strings.ToLower(a.Name) < strings.ToLower(b.Name)
+	case sortByDuration:
+		less = a.Duration < b.Duration
+	case sortByAge:
+		less = a.ModTime.Before(b.ModTime)
+	}
+	if m.sortAscending {
+		return less
+	}
+	return !less
+}
+
+func (m *model) updateTableRows() {
+	rows := make([]table.Row, 0, len(m.filtered))
+	for _, v := range m.filtered {
+		rows = append(rows, videoRow(v))
+	}
+	m.table.SetRows(rows)
+	if len(rows) > 0 {
+		m.table.SetCursor(0)
+	}
+}
diff --git a/internal/app/model_test.go b/internal/app/model_test.go
new file mode 100644
index 0000000..53e391e
--- /dev/null
+++ b/internal/app/model_test.go
@@ -0,0 +1,482 @@
+package app
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestModelHandleVideosLoadedAndSort(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	videos := []video{
+		{Name: "B.mp4", Path: filepath.Join(root, "B.mp4"), Duration: time.Minute, ModTime: time.Now()},
+		{Name: "A.mp4", Path: filepath.Join(root, "A.mp4"), Duration: 2 * time.Minute, ModTime: time.Now().Add(-time.Hour)},
+	}
+	msg := videosLoadedMsg{videos: videos, pending: nil, cache: newDurationCache(filepath.Join(root, "cache.json"))}
+	modelAny, cmd := m.handleVideosLoaded(msg)
+	if cmd != nil {
+		t.Fatalf("expected no duration command")
+	}
+	m = modelAny.(model)
+	if len(m.filtered) != 2 {
+		t.Fatalf("expected 2 videos, got %d", len(m.filtered))
+	}
+	if m.filtered[0].Name != "A.mp4" {
+		t.Fatalf("expected sorted by name ascending")
+	}
+	modelAny, _ = m.handleKeyMsg(keyMsg("l"))
+	m = modelAny.(model)
+	if m.filtered[0].Name != "B.mp4" {
+		t.Fatalf("expected shortest duration first")
+	}
+}
+
+func TestModelHandleDurationUpdateCompletes(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	pendingPath := filepath.Join(root, "pending.mp4")
+	videos := []video{{Name: "pending.mp4", Path: pendingPath}}
+	msg := videosLoadedMsg{videos: videos, pending: []string{pendingPath}, cache: newDurationCache(filepath.Join(root, "cache.json"))}
+	modelAny, cmd := m.handleVideosLoaded(msg)
+	if cmd == nil {
+		t.Fatalf("expected duration command")
+	}
+	m = modelAny.(model)
+	durMsg := durationUpdateMsg{path: pendingPath, duration: time.Minute}
+	modelAny, next := m.handleDurationUpdate(durMsg)
+	m = modelAny.(model)
+	if next != nil {
+		t.Fatalf("expected no further command after completion")
+	}
+	if m.durationDone != 0 || m.pendingDurations != nil {
+		t.Fatalf("expected duration queue cleared")
+	}
+}
+
+func TestModelFiltersWorkflow(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	videos := []video{{Name: "morning flow.mp4", Path: filepath.Join(root, "morning.mp4"), Duration: 10 * time.Minute}}
+	modelAny, _ := m.handleVideosLoaded(videosLoadedMsg{videos: videos, cache: newDurationCache(filepath.Join(root, "cache.json"))})
+	m = modelAny.(model)
+	modelAny, _ = m.handleKeyMsg(keyMsg("/"))
+	m = modelAny.(model)
+	if !m.showFilters {
+		t.Fatalf("expected filters to open")
+	}
+	m.inputs.fields[0].SetValue("morning")
+	inputs, _ := m.updateFilterInputs(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	m.inputs = inputs
+	m.inputs.fields[0].SetValue("morning")
+	if modal := m.renderFilterModal(); !strings.Contains(modal, "Filter videos") {
+		t.Fatalf("expected filter modal content")
+	}
+	modelAny, _ = m.handleKeyMsg(tea.KeyMsg{Type: tea.KeyEnter})
+	m = modelAny.(model)
+	if len(m.filtered) != 1 {
+		t.Fatalf("expected filtered result")
+	}
+}
+
+func TestRenderProgressBar(t *testing.T) {
+	bar := renderProgressBar(5, 10, 10)
+	if bar != "[#####-----]" {
+		t.Fatalf("unexpected bar %s", bar)
+	}
+	if renderProgressBar(0, 0, 10) != "" {
+		t.Fatalf("expected empty bar for zero total")
+	}
+	if renderProgressBar(-1, 10, 5) == "" {
+		t.Fatalf("expected bar even when done negative")
+	}
+}
+
+func TestModelViewAndProgress(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = false
+	m.statusMessage = "Ready"
+	m.filtered = []video{}
+	view := m.View()
+	if view == "" {
+		t.Fatalf("expected non-empty view")
+	}
+	m.durationTotal = 10
+	m.durationDone = 5
+	if line := m.renderProgressLine(); !strings.Contains(line, "5/10") {
+		t.Fatalf("unexpected progress line %s", line)
+	}
+}
+
+func TestModelInitAndUpdate(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	cmd := m.Init()
+	if cmd == nil {
+		t.Fatalf("expected init command")
+	}
+	m.loading = false
+	modelAny, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
+	m = modelAny.(model)
+	if m.filters.name != "" || !strings.Contains(m.statusMessage, "Filters cleared") {
+		t.Fatalf("expected filters reset via update path")
+	}
+	m.loading = true
+	modelAny, cmd = m.Update(progressUpdateMsg{processed: 1, total: 2, done: false})
+	m = modelAny.(model)
+	if cmd == nil || !strings.Contains(m.statusMessage, "Loading videos") {
+		t.Fatalf("unexpected status %s", m.statusMessage)
+	}
+}
+
+func TestHandlePlayVideoStatuses(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m = m.handlePlayVideo(playVideoMsg{path: "video.mp4", err: errors.New("fail")})
+	if !strings.Contains(m.statusMessage, "Failed") {
+		t.Fatalf("expected failure message")
+	}
+	m = m.handlePlayVideo(playVideoMsg{path: "video.mp4"})
+	if !strings.Contains(m.statusMessage, "Playing") {
+		t.Fatalf("expected playing message")
+	}
+}
+
+func TestDescribeFilters(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.filters = filterState{name: "flow", minEnabled: true, minMinutes: 5, maxEnabled: true, maxMinutes: 20}
+	desc := m.describeFilters()
+	if !strings.Contains(desc, "flow") || !strings.Contains(desc, ">=5") {
+		t.Fatalf("unexpected description %s", desc)
+	}
+}
+
+func TestPlaySelectionCommand(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = false
+	m.filtered = []video{{Name: "clip", Path: "clip.mp4"}}
+	cmdModel, cmd := m.playSelection()
+	if cmd == nil {
+		t.Fatalf("expected command to play video")
+	}
+	if cmdModel.(model).statusMessage == "" {
+		t.Fatalf("expected status message set")
+	}
+}
+
+func TestUpdateTableFallback(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = false
+	m.handleKeyMsg(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'z'}})
+}
+
+func TestProgressTickerNil(t *testing.T) {
+	if progressTickerCmd(nil) != nil {
+		t.Fatalf("expected nil command for nil progress")
+	}
+}
+
+func TestHandleFilterKeyTabs(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.showFilters = true
+	m.inputs = buildFilterInputs()
+	m.inputs.fields[0].Focus()
+	modelAny, _ := m.handleFilterKey(tea.KeyMsg{Type: tea.KeyTab})
+	m = modelAny.(model)
+	if !m.inputs.fields[1].Focused() {
+		t.Fatalf("expected focus to move forward")
+	}
+	modelAny, _ = m.handleFilterKey(tea.KeyMsg{Type: tea.KeyShiftTab})
+	m = modelAny.(model)
+	if !m.inputs.fields[0].Focused() {
+		t.Fatalf("expected focus to move back")
+	}
+}
+
+func TestUpdateStatusAfterLoadBranches(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	videos := []video{{Name: "a", Path: "a.mp4"}}
+	msg := videosLoadedMsg{videos: videos, pending: []string{"a.mp4"}, cacheErr: errors.New("cache"), cache: newDurationCache("cache.json")}
+	modelAny, cmd := m.handleVideosLoaded(msg)
+	m = modelAny.(model)
+	if cmd == nil {
+		t.Fatalf("expected pending duration command")
+	}
+	if !strings.Contains(m.statusMessage, "cache warning") {
+		t.Fatalf("expected cache warning status")
+	}
+}
+
+func TestModelUpdateWithVideosLoaded(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	videos := []video{{Name: "a", Path: "a.mp4"}}
+	msg := videosLoadedMsg{videos: videos}
+	modelAny, _ := m.Update(msg)
+	m = modelAny.(model)
+	if len(m.videos) != 1 {
+		t.Fatalf("expected videos loaded")
+	}
+}
+
+func TestModelUpdatePlayVideoMsg(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m = m.handlePlayVideo(playVideoMsg{path: "a.mp4"})
+	modelAny, _ := m.Update(playVideoMsg{path: "a.mp4"})
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "Playing") {
+		t.Fatalf("expected playing status, got %s", m.statusMessage)
+	}
+}
+
+func TestModelUpdateDurationMsg(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.videos = []video{{Name: "a", Path: "a.mp4"}}
+	m.filtered = m.videos
+	m.pendingDurations = []string{"a.mp4"}
+	m.durationTotal = 1
+	m.cache = newDurationCache("cache.json")
+	update := durationUpdateMsg{path: "a.mp4", duration: time.Second}
+	modelAny, _ := m.Update(update)
+	m = modelAny.(model)
+	if m.durationTotal != 0 {
+		t.Fatalf("expected duration queue cleared")
+	}
+}
+
+func TestUpdateStatusForDurationError(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.videos = []video{{Name: "a", Path: "a.mp4"}, {Name: "b", Path: "b.mp4"}}
+	m.filtered = m.videos
+	m.pendingDurations = []string{"a.mp4", "b.mp4"}
+	m.durationTotal = 2
+	m.durationInFlight = 1
+	m.cache = newDurationCache("cache.json")
+	msg := durationUpdateMsg{path: "a.mp4", err: errors.New("ffprobe")}
+	modelAny, _ := m.Update(msg)
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "Duration error") {
+		t.Fatalf("expected error status, got %s", m.statusMessage)
+	}
+}
+
+func TestHandleProgressUpdateDone(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = true
+	modelAny, _ := m.handleProgressUpdate(progressUpdateMsg{total: 2, done: true})
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "Loaded") {
+		t.Fatalf("expected loaded status, got %s", m.statusMessage)
+	}
+}
+
+func TestUpdateStatusAfterLoadCacheWarning(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	msg := videosLoadedMsg{videos: []video{{Name: "a", Path: "a.mp4"}}, cacheErr: errors.New("oops"), cache: newDurationCache("cache.json")}
+	modelAny, _ := m.Update(msg)
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "cache warning") {
+		t.Fatalf("expected cache warning, got %s", m.statusMessage)
+	}
+}
+
+func TestPassesFiltersBounds(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.filters = filterState{minEnabled: true, minMinutes: 5, maxEnabled: true, maxMinutes: 15}
+	video := video{Name: "clip", Duration: 10 * time.Minute}
+	if !m.passesFilters(video) {
+		t.Fatalf("expected video within bounds")
+	}
+	m.filters.maxMinutes = 5
+	if m.passesFilters(video) {
+		t.Fatalf("expected video to fail with tighter max")
+	}
+	m.filters = filterState{name: "yoga"}
+	if m.passesFilters(video) {
+		t.Fatalf("expected name filter to exclude video")
+	}
+}
+
+func TestProgressTickerCmdTick(t *testing.T) {
+	progress := &loadProgress{}
+	progress.SetTotal(2)
+	cmd := progressTickerCmd(progress)
+	if cmd == nil {
+		t.Fatalf("expected command")
+	}
+	msg := cmd().(progressUpdateMsg)
+	if msg.total != 2 {
+		t.Fatalf("unexpected ticker message %#v", msg)
+	}
+}
+
+func TestProgressUpdateMessages(t *testing.T) {
+	root := t.TempDir()
+	m, err := newModel(Options{Root: root})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	modelAny, cmd := m.handleProgressUpdate(progressUpdateMsg{processed: 1, total: 3, done: false})
+	if cmd == nil {
+		t.Fatalf("expected ticker command")
+	}
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "Loading videos") {
+		t.Fatalf("unexpected status %s", m.statusMessage)
+	}
+	modelAny, cmd = m.handleProgressUpdate(progressUpdateMsg{total: 0, done: true})
+	m = modelAny.(model)
+	if cmd != nil || m.statusMessage != "No videos found" {
+		t.Fatalf("expected no videos message")
+	}
+}
+
+func TestToggleCrop(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir(), Crop: "5:4"})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = false
+	modelAny, _ := m.handleKeyMsg(keyMsg("c"))
+	m = modelAny.(model)
+	if m.statusMessage != "Crop disabled" {
+		t.Fatalf("expected crop disabled, got %s", m.statusMessage)
+	}
+	modelAny, _ = m.handleKeyMsg(keyMsg("c"))
+	m = modelAny.(model)
+	if !strings.Contains(m.statusMessage, "Crop enabled") {
+		t.Fatalf("expected crop enabled, got %s", m.statusMessage)
+	}
+	if m.activeCrop() == "" {
+		t.Fatalf("expected active crop")
+	}
+}
+
+func TestToggleSort(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.toggleSort(sortByDuration)
+	if m.sortField != sortByDuration || !m.sortAscending {
+		t.Fatalf("expected sort by duration ascending")
+	}
+	m.toggleSort(sortByDuration)
+	if m.sortAscending {
+		t.Fatalf("expected sort order to flip")
+	}
+}
+
+func TestResetFilters(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.loading = false
+	m.filters = filterState{name: "x"}
+	modelAny, _ := m.handleKeyMsg(keyMsg("r"))
+	m = modelAny.(model)
+	if m.filters.name != "" {
+		t.Fatalf("expected filters cleared")
+	}
+}
+
+func TestSyncFilterFocus(t *testing.T) {
+	m, err := newModel(Options{Root: t.TempDir()})
+	if err != nil {
+		t.Fatalf("newModel: %v", err)
+	}
+	m.showFilters = true
+	m.inputs.focus = 1
+	m.syncFilterFocus()
+	if !m.inputs.fields[1].Focused() {
+		t.Fatalf("expected second field focused")
+	}
+}
+
+func TestLoadVideosCmdProducesMessage(t *testing.T) {
+	root := t.TempDir()
+	video := filepath.Join(root, "clip.mp4")
+	if err := os.WriteFile(video, []byte("x"), 0o644); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	cmd := loadVideosCmd(root, filepath.Join(root, "cache.json"), &loadProgress{})
+	msg := cmd()
+	if _, ok := msg.(videosLoadedMsg); !ok {
+		t.Fatalf("expected videosLoadedMsg")
+	}
+}
+
+func TestProgressTickerCmdProducesMsg(t *testing.T) {
+	progress := &loadProgress{}
+	progress.SetTotal(1)
+	cmd := progressTickerCmd(progress)
+	if cmd == nil {
+		t.Fatalf("expected ticker command")
+	}
+}
+
+func keyMsg(value string) tea.KeyMsg {
+	if len(value) == 1 {
+		return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(value)}
+	}
+	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(value), Alt: false}
+}
diff --git a/internal/app/options.go b/internal/app/options.go
new file mode 100644
index 0000000..9292e53
--- /dev/null
+++ b/internal/app/options.go
@@ -0,0 +1,7 @@
+package app
+
+// Options configures the Yoga application runtime.
+type Options struct {
+	Root string
+	Crop string
+}
diff --git a/internal/app/style.go b/internal/app/style.go
new file mode 100644
index 0000000..de26b8a
--- /dev/null
+++ b/internal/app/style.go
@@ -0,0 +1,19 @@
+package app
+
+import "github.com/charmbracelet/lipgloss"
+
+var (
+	videoExtensions = map[string]struct{}{
+		".mp4": {},
+		".mkv": {},
+		".mov": {},
+		".avi": {},
+		".wmv": {},
+		".m4v": {},
+	}
+	tableStyle     = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("63")).Padding(0, 1)
+	headerStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("99")).Bold(true)
+	filterStyle    = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("105")).Padding(1, 2)
+	statusStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
+	highlightStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
+)
diff --git a/internal/app/video.go b/internal/app/video.go
new file mode 100644
index 0000000..f969ce6
--- /dev/null
+++ b/internal/app/video.go
@@ -0,0 +1,12 @@
+package app
+
+import "time"
+
+type video struct {
+	Name     string
+	Path     string
+	Duration time.Duration
+	ModTime  time.Time
+	Size     int64
+	Err      error
+}
diff --git a/internal/app/view_helpers.go b/internal/app/view_helpers.go
new file mode 100644
index 0000000..b023d62
--- /dev/null
+++ b/internal/app/view_helpers.go
@@ -0,0 +1,80 @@
+package app
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/bubbles/table"
+)
+
+func videoRow(v video) table.Row {
+	duration := "(unknown)"
+	if v.Duration > 0 {
+		duration = formatDuration(v.Duration)
+	}
+	age := humanizeAge(v.ModTime)
+	path := trimPath(v.Path)
+	if v.Err != nil {
+		duration = "!" + v.Err.Error()
+	}
+	return table.Row{v.Name, duration, age, path}
+}
+
+func renderProgressBar(done, total, width int) string {
+	if width <= 0 || total <= 0 {
+		return ""
+	}
+	if done < 0 {
+		done = 0
+	}
+	if done > total {
+		done = total
+	}
+	filled := int(float64(done) / float64(total) * float64(width))
+	if filled > width {
+		filled = width
+	}
+	bar := strings.Repeat("#", filled) + strings.Repeat("-", width-filled)
+	return fmt.Sprintf("[%s]", bar)
+}
+
+func formatDuration(d time.Duration) string {
+	if d <= 0 {
+		return "--"
+	}
+	totalSeconds := int(d.Seconds() + 0.5)
+	hours := totalSeconds / 3600
+	minutes := (totalSeconds % 3600) / 60
+	seconds := totalSeconds % 60
+	if hours > 0 {
+		return fmt.Sprintf("%d:%02d:%02d", hours, minutes, seconds)
+	}
+	return fmt.Sprintf("%02d:%02d", minutes, seconds)
+}
+
+func humanizeAge(t time.Time) string {
+	if t.IsZero() {
+		return "--"
+	}
+	dur := time.Since(t)
+	if dur < time.Minute {
+		return "just now"
+	}
+	if dur < time.Hour {
+		return fmt.Sprintf("%dm ago", int(dur.Minutes()))
+	}
+	if dur < 24*time.Hour {
+		return fmt.Sprintf("%dh ago", int(dur.Hours()))
+	}
+	return t.Format("2006-01-02")
+}
+
+func trimPath(path string) string {
+	home, err := os.UserHomeDir()
+	if err == nil && strings.HasPrefix(path, home) {
+		return "~" + strings.TrimPrefix(path, home)
+	}
+	return path
+}
diff --git a/internal/fsutil/path.go b/internal/fsutil/path.go
new file mode 100644
index 0000000..c872a5b
--- /dev/null
+++ b/internal/fsutil/path.go
@@ -0,0 +1,99 @@
+package fsutil
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+)
+
+// ResolveRootPath expands and validates the supplied root path. When the
+// caller did not specify a value, defaultValue is used and created on demand.
+func ResolveRootPath(input, defaultValue string) (string, error) {
+	value, isDefault := normalizeRootInput(input, defaultValue)
+	expanded, err := expandPath(value)
+	if err != nil {
+		return "", fmt.Errorf("cannot expand root path %q: %w", value, err)
+	}
+	abs, err := filepath.Abs(expanded)
+	if err != nil {
+		return "", fmt.Errorf("cannot resolve root path %q: %w", expanded, err)
+	}
+	info, err := ensureRootExists(abs, isDefault)
+	if err != nil {
+		return "", err
+	}
+	if !info.IsDir() && !info.Mode().IsRegular() {
+		return "", fmt.Errorf("root path %q is not a file or directory", abs)
+	}
+	return abs, nil
+}
+
+func normalizeRootInput(input, defaultValue string) (value string, isDefault bool) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return defaultValue, true
+	}
+	return trimmed, false
+}
+
+func ensureRootExists(path string, allowCreate bool) (fs.FileInfo, error) {
+	info, err := os.Stat(path)
+	if err == nil {
+		return info, nil
+	}
+	if !errors.Is(err, fs.ErrNotExist) {
+		return nil, fmt.Errorf("cannot access root path %q: %w", path, err)
+	}
+	if !allowCreate {
+		return nil, fmt.Errorf("root path does not exist: %s", path)
+	}
+	if mkErr := os.MkdirAll(path, 0o755); mkErr != nil {
+		return nil, fmt.Errorf("cannot create default directory %q: %w", path, mkErr)
+	}
+	info, err = os.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("cannot stat default directory %q: %w", path, err)
+	}
+	return info, nil
+}
+
+func expandPath(p string) (string, error) {
+	if p == "" || p[0] != '~' {
+		return p, nil
+	}
+	if len(p) == 1 {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		return home, nil
+	}
+	if p[1] == '/' {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return "", err
+		}
+		return filepath.Join(home, p[2:]), nil
+	}
+	username, rest := splitUserPath(p)
+	usr, err := user.Lookup(username)
+	if err != nil {
+		return "", err
+	}
+	if rest == "" {
+		return usr.HomeDir, nil
+	}
+	return filepath.Join(usr.HomeDir, rest), nil
+}
+
+func splitUserPath(p string) (string, string) {
+	sep := strings.IndexRune(p, '/')
+	if sep == -1 {
+		return p[1:], ""
+	}
+	return p[1:sep], p[sep:]
+}
diff --git a/internal/fsutil/path_test.go b/internal/fsutil/path_test.go
new file mode 100644
index 0000000..4b88573
--- /dev/null
+++ b/internal/fsutil/path_test.go
@@ -0,0 +1,112 @@
+package fsutil
+
+import (
+	"os"
+	"os/user"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveRootPathCreatesDefault(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	root, err := ResolveRootPath("", "~/Yoga")
+	if err != nil {
+		t.Fatalf("resolve root: %v", err)
+	}
+	expected := filepath.Join(home, "Yoga")
+	if root != expected {
+		t.Fatalf("expected %s, got %s", expected, root)
+	}
+	info, err := os.Stat(expected)
+	if err != nil {
+		t.Fatalf("stat default: %v", err)
+	}
+	if !info.IsDir() {
+		t.Fatalf("expected directory at %s", expected)
+	}
+}
+
+func TestResolveRootPathRequiresExisting(t *testing.T) {
+	tmp := t.TempDir()
+	missing := filepath.Join(tmp, "missing")
+	if _, err := ResolveRootPath(missing, "~/Yoga"); err == nil {
+		t.Fatalf("expected error for %s", missing)
+	}
+}
+
+func TestResolveRootPathAllowsFile(t *testing.T) {
+	tmp := t.TempDir()
+	file := filepath.Join(tmp, "video.mp4")
+	if err := os.WriteFile(file, []byte("x"), 0o644); err != nil {
+		t.Fatalf("write file: %v", err)
+	}
+	got, err := ResolveRootPath(file, "~/Yoga")
+	if err != nil {
+		t.Fatalf("resolve root: %v", err)
+	}
+	if got != file {
+		t.Fatalf("expected file path returned, got %s", got)
+	}
+}
+
+func TestExpandPathWithHome(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	custom := filepath.Join(home, "custom")
+	if err := os.MkdirAll(custom, 0o755); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	got, err := ResolveRootPath("~/custom", "~/Yoga")
+	if err != nil {
+		t.Fatalf("resolve root: %v", err)
+	}
+	expected := filepath.Join(home, "custom")
+	if got != expected {
+		t.Fatalf("expected %s, got %s", expected, got)
+	}
+	if v, err := expandPath("~"); err != nil || v != home {
+		t.Fatalf("expandPath ~ failed: %v %s", err, v)
+	}
+	if _, err := expandPath("~no_such_user/foo"); err == nil {
+		t.Fatalf("expected error for unknown user")
+	}
+	if path, err := expandPath("relative/path"); err != nil || path != "relative/path" {
+		t.Fatalf("expected relative path unchanged, got %s %v", path, err)
+	}
+	if current, err := user.Current(); err == nil {
+		value := "~" + current.Username
+		if p, err := expandPath(value); err != nil || p != current.HomeDir {
+			t.Fatalf("expected home dir %s, got %s (%v)", current.HomeDir, p, err)
+		}
+	}
+}
+
+func TestSplitUserPath(t *testing.T) {
+	user, rest := splitUserPath("~alice/videos")
+	if user != "alice" || rest != "/videos" {
+		t.Fatalf("unexpected split %s %s", user, rest)
+	}
+	user, rest = splitUserPath("~bob")
+	if user != "bob" || rest != "" {
+		t.Fatalf("unexpected split %s %s", user, rest)
+	}
+}
+
+func TestNormalizeRootInput(t *testing.T) {
+	const fallback = "~/Yoga"
+	value, isDefault := normalizeRootInput("", fallback)
+	if !isDefault || value != fallback {
+		t.Fatalf("unexpected normalize result %s %v", value, isDefault)
+	}
+	value, isDefault = normalizeRootInput(" /tmp ", fallback)
+	if isDefault || value != "/tmp" {
+		t.Fatalf("unexpected normalize result %s %v", value, isDefault)
+	}
+}
+
+func TestEnsureRootExistsErrors(t *testing.T) {
+	if _, err := ensureRootExists(filepath.Join(t.TempDir(), "missing"), false); err == nil {
+		t.Fatalf("expected error when creation not allowed")
+	}
+}
diff --git a/internal/meta/version.go b/internal/meta/version.go
new file mode 100644
index 0000000..687450b
--- /dev/null
+++ b/internal/meta/version.go
@@ -0,0 +1,3 @@
+package meta
+
+const Version = "v0.2.0"
diff --git a/magefile.go b/magefile.go
new file mode 100644
index 0000000..8b14824
--- /dev/null
+++ b/magefile.go
@@ -0,0 +1,78 @@
+//go:build mage
+
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+var Default = Build
+
+// Build compiles the yoga binary.
+func Build() error {
+	return run("go", "build", "./cmd/yoga")
+}
+
+// Test runs the unit test suite.
+func Test() error {
+	return run("go", "test", "./...")
+}
+
+// Install installs the yoga binary into GOPATH/bin or GOBIN.
+func Install() error {
+	return run("go", "install", "./cmd/yoga")
+}
+
+// Coverage runs the unit tests with coverage and enforces the minimum target.
+func Coverage() error {
+	profile := filepath.Join(os.TempDir(), "yoga-coverage.out")
+	if err := run("go", "test", "-coverprofile="+profile, "./..."); err != nil {
+		return err
+	}
+	defer os.Remove(profile)
+	out, err := exec.Command("go", "tool", "cover", "-func="+profile).CombinedOutput()
+	if err != nil {
+		fmt.Print(string(out))
+		return err
+	}
+	fmt.Print(string(out))
+	total, err := parseTotalCoverage(string(out))
+	if err != nil {
+		return err
+	}
+	if total < 85.0 {
+		return fmt.Errorf("coverage %.1f%% below required 85%%", total)
+	}
+	return nil
+}
+
+func parseTotalCoverage(report string) (float64, error) {
+	lines := strings.Split(strings.TrimSpace(report), "\n")
+	if len(lines) == 0 {
+		return 0, errors.New("empty coverage report")
+	}
+	last := lines[len(lines)-1]
+	fields := strings.Fields(last)
+	if len(fields) < 3 {
+		return 0, fmt.Errorf("unexpected coverage line: %s", last)
+	}
+	value := strings.TrimSuffix(fields[len(fields)-1], "%")
+	percent, err := strconv.ParseFloat(value, 64)
+	if err != nil {
+		return 0, err
+	}
+	return percent, nil
+}
+
+func run(command string, args ...string) error {
+	cmd := exec.Command(command, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
diff --git a/main.go b/main.go
deleted file mode 100644
index 06e16ea..0000000
--- a/main.go
+++ /dev/null
@@ -1,1207 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"io/fs"
-	"os"
-	"os/exec"
-	"os/user"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/charmbracelet/bubbles/table"
-	"github.com/charmbracelet/bubbles/textinput"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-)
-
-const Version = "v0.1.0"
-
-var (
-	videoExtensions = map[string]struct{}{
-		".mp4": {},
-		".mkv": {},
-		".mov": {},
-		".avi": {},
-		".wmv": {},
-		".m4v": {},
-	}
-	tableStyle     = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("63")).Padding(0, 1)
-	headerStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("99")).Bold(true)
-	filterStyle    = lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(lipgloss.Color("105")).Padding(1, 2)
-	statusStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("244"))
-	highlightStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
-)
-
-type video struct {
-	Name     string
-	Path     string
-	Duration time.Duration
-	ModTime  time.Time
-	Size     int64
-	Err      error
-}
-
-type videosLoadedMsg struct {
-	videos   []video
-	err      error
-	cacheErr error
-	pending  []string
-	cache    *durationCache
-}
-
-type playVideoMsg struct {
-	path string
-	err  error
-}
-
-type progressUpdateMsg struct {
-	processed int
-	total     int
-	done      bool
-}
-
-type durationUpdateMsg struct {
-	path     string
-	duration time.Duration
-	err      error
-}
-
-type loadProgress struct {
-	mu        sync.Mutex
-	total     int
-	processed int
-	done      bool
-}
-
-func (p *loadProgress) Reset() {
-	if p == nil {
-		return
-	}
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.total = 0
-	p.processed = 0
-	p.done = false
-}
-
-func (p *loadProgress) SetTotal(total int) {
-	if p == nil {
-		return
-	}
-	p.mu.Lock()
-	p.total = total
-	p.mu.Unlock()
-}
-
-func (p *loadProgress) Increment() {
-	if p == nil {
-		return
-	}
-	p.mu.Lock()
-	p.processed++
-	p.mu.Unlock()
-}
-
-func (p *loadProgress) MarkDone() {
-	if p == nil {
-		return
-	}
-	p.mu.Lock()
-	p.done = true
-	p.mu.Unlock()
-}
-
-func (p *loadProgress) Snapshot() (processed, total int, done bool) {
-	if p == nil {
-		return 0, 0, true
-	}
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.processed, p.total, p.done
-}
-
-type cacheEntry struct {
-	DurationSeconds float64 `json:"duration_seconds"`
-	ModTimeUnix     int64   `json:"mod_time_unix"`
-	Size            int64   `json:"size"`
-}
-
-type durationCache struct {
-	path    string
-	entries map[string]cacheEntry
-	mu      sync.Mutex
-	dirty   bool
-}
-
-func newDurationCache(path string) *durationCache {
-	return &durationCache{
-		path:    path,
-		entries: make(map[string]cacheEntry),
-	}
-}
-
-func loadDurationCache(path string) (*durationCache, error) {
-	cache := newDurationCache(path)
-	data, err := os.ReadFile(path)
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			return cache, nil
-		}
-		return cache, err
-	}
-	if len(data) == 0 {
-		return cache, nil
-	}
-	if err := json.Unmarshal(data, &cache.entries); err != nil {
-		cache.entries = make(map[string]cacheEntry)
-		return cache, err
-	}
-	return cache, nil
-}
-
-func (c *durationCache) Lookup(path string, info os.FileInfo) (time.Duration, bool) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	entry, ok := c.entries[path]
-	if !ok {
-		return 0, false
-	}
-	if entry.ModTimeUnix != info.ModTime().Unix() || entry.Size != info.Size() {
-		delete(c.entries, path)
-		c.dirty = true
-		return 0, false
-	}
-	if entry.DurationSeconds <= 0 {
-		return 0, false
-	}
-	return time.Duration(entry.DurationSeconds * float64(time.Second)), true
-}
-
-func (c *durationCache) Record(path string, info os.FileInfo, dur time.Duration) error {
-	if c == nil || dur <= 0 {
-		return nil
-	}
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.entries == nil {
-		c.entries = make(map[string]cacheEntry)
-	}
-	c.entries[path] = cacheEntry{
-		DurationSeconds: dur.Seconds(),
-		ModTimeUnix:     info.ModTime().Unix(),
-		Size:            info.Size(),
-	}
-	c.dirty = true
-	return nil
-}
-
-func (c *durationCache) Flush() error {
-	if c == nil {
-		return nil
-	}
-	c.mu.Lock()
-	if !c.dirty {
-		c.mu.Unlock()
-		return nil
-	}
-	snapshot := make(map[string]cacheEntry, len(c.entries))
-	for k, v := range c.entries {
-		snapshot[k] = v
-	}
-	c.dirty = false
-	c.mu.Unlock()
-
-	data, err := json.MarshalIndent(snapshot, "", "  ")
-	if err != nil {
-		return err
-	}
-	tmp := c.path + ".tmp"
-	if err := os.WriteFile(tmp, data, 0o644); err != nil {
-		return err
-	}
-	return os.Rename(tmp, c.path)
-}
-
-type sortField int
-
-const (
-	sortByName sortField = iota
-	sortByDuration
-	sortByAge
-)
-
-type filterState struct {
-	name       string
-	minEnabled bool
-	minMinutes int
-	maxEnabled bool
-	maxMinutes int
-}
-
-type filterInputs struct {
-	fields []textinput.Model
-	focus  int
-}
-
-type model struct {
-	table            table.Model
-	videos           []video
-	filtered         []video
-	filters          filterState
-	inputs           filterInputs
-	showFilters      bool
-	sortField        sortField
-	sortAscending    bool
-	statusMessage    string
-	loading          bool
-	err              error
-	root             string
-	progress         *loadProgress
-	cachePath        string
-	cache            *durationCache
-	pendingDurations []string
-	durationTotal    int
-	durationDone     int
-	durationInFlight int
-	cropValue        string
-	cropEnabled      bool
-}
-
-func main() {
-	rootFlag := flag.String("root", "", "Directory containing yoga videos (default ~/Yoga)")
-	crop := flag.String("crop", "", "Optional crop aspect for VLC (e.g. 5:4)")
-	printVersion := flag.Bool("version", false, "Print version and exit")
-	flag.Parse()
-
-	if *printVersion {
-		fmt.Println("Yoga version", Version)
-		os.Exit(0)
-	}
-
-	root, err := resolveRootPath(*rootFlag)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
-		os.Exit(1)
-	}
-
-	m := newModel(root, strings.TrimSpace(*crop))
-	if err := tea.NewProgram(m, tea.WithAltScreen()).Start(); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-func resolveRootPath(flagValue string) (string, error) {
-	value := strings.TrimSpace(flagValue)
-	isDefault := value == ""
-	if isDefault {
-		value = "~/Yoga"
-	}
-	expanded, err := expandPath(value)
-	if err != nil {
-		return "", fmt.Errorf("cannot expand root path %q: %w", value, err)
-	}
-	abs, err := filepath.Abs(expanded)
-	if err != nil {
-		return "", fmt.Errorf("cannot resolve root path %q: %w", expanded, err)
-	}
-	info, statErr := os.Stat(abs)
-	if statErr != nil {
-		if errors.Is(statErr, fs.ErrNotExist) {
-			if isDefault {
-				if mkErr := os.MkdirAll(abs, 0o755); mkErr != nil {
-					return "", fmt.Errorf("cannot create default directory %q: %w", abs, mkErr)
-				}
-				info, statErr = os.Stat(abs)
-				if statErr != nil {
-					return "", fmt.Errorf("cannot stat default directory %q: %w", abs, statErr)
-				}
-			} else {
-				return "", fmt.Errorf("root path does not exist: %s", abs)
-			}
-		} else {
-			return "", fmt.Errorf("cannot access root path %q: %w", abs, statErr)
-		}
-	}
-	if info.IsDir() || info.Mode().IsRegular() {
-		return abs, nil
-	}
-	return "", fmt.Errorf("root path %q is not a file or directory", abs)
-}
-
-func expandPath(p string) (string, error) {
-	if p == "" || p[0] != '~' {
-		return p, nil
-	}
-	if len(p) == 1 {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-		return home, nil
-	}
-	if p[1] == '/' {
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", err
-		}
-		return filepath.Join(home, p[2:]), nil
-	}
-	sep := strings.IndexRune(p, '/')
-	var username, rest string
-	if sep == -1 {
-		username = p[1:]
-	} else {
-		username = p[1:sep]
-		rest = p[sep:]
-	}
-	usr, err := user.Lookup(username)
-	if err != nil {
-		return "", err
-	}
-	if rest == "" {
-		return usr.HomeDir, nil
-	}
-	return filepath.Join(usr.HomeDir, rest), nil
-}
-
-func newModel(root, vlcCrop string) model {
-	columns := []table.Column{
-		{Title: headerStyle.Render("Name"), Width: 50},
-		{Title: headerStyle.Render("Duration"), Width: 12},
-		{Title: headerStyle.Render("Age"), Width: 14},
-		{Title: headerStyle.Render("Path"), Width: 40},
-	}
-
-	tbl := table.New(
-		table.WithColumns(columns),
-		table.WithFocused(true),
-		table.WithHeight(15),
-	)
-	tbl.SetStyles(table.DefaultStyles())
-
-	nameInput := textinput.New()
-	nameInput.Placeholder = "substring"
-	nameInput.Prompt = "Name: "
-	nameInput.CharLimit = 256
-
-	minInput := textinput.New()
-	minInput.Placeholder = "min minutes"
-	minInput.Prompt = "Min minutes: "
-	minInput.CharLimit = 4
-	minInput.SetValue("")
-
-	maxInput := textinput.New()
-	maxInput.Placeholder = "max minutes"
-	maxInput.Prompt = "Max minutes: "
-	maxInput.CharLimit = 4
-	maxInput.SetValue("")
-
-	inputs := filterInputs{
-		fields: []textinput.Model{nameInput, minInput, maxInput},
-		focus:  0,
-	}
-	inputs.fields[0].Focus()
-
-	progress := &loadProgress{}
-	cachePath := filepath.Join(root, ".video_duration_cache.json")
-
-	return model{
-		table:         tbl,
-		inputs:        inputs,
-		sortField:     sortByName,
-		sortAscending: true,
-		statusMessage: "Scanning for videos...",
-		loading:       true,
-		root:          root,
-		progress:      progress,
-		cachePath:     cachePath,
-		cropValue:     vlcCrop,
-		cropEnabled:   vlcCrop != "",
-	}
-}
-
-func (m model) Init() tea.Cmd {
-	if m.progress != nil {
-		m.progress.Reset()
-	}
-	loadCmd := loadVideosCmd(m.root, m.cachePath, m.progress)
-	if m.progress != nil {
-		return tea.Batch(loadCmd, progressTickerCmd(m.progress))
-	}
-	return loadCmd
-}
-
-func loadVideosCmd(root, cachePath string, progress *loadProgress) tea.Cmd {
-	return func() tea.Msg {
-		cache, cacheErr := loadDurationCache(cachePath)
-		vids, pending, err := loadVideos(root, cache, progress)
-		if progress != nil {
-			progress.MarkDone()
-		}
-		return videosLoadedMsg{videos: vids, err: err, cacheErr: cacheErr, pending: pending, cache: cache}
-	}
-}
-
-func progressTickerCmd(progress *loadProgress) tea.Cmd {
-	if progress == nil {
-		return nil
-	}
-	return tea.Tick(200*time.Millisecond, func(time.Time) tea.Msg {
-		processed, total, done := progress.Snapshot()
-		return progressUpdateMsg{processed: processed, total: total, done: done}
-	})
-}
-
-func collectVideoPaths(root string) ([]string, error) {
-	info, err := os.Stat(root)
-	if err != nil {
-		return nil, err
-	}
-	if !info.IsDir() {
-		if isVideo(root) {
-			return []string{root}, nil
-		}
-		return nil, nil
-	}
-	visited := make(map[string]struct{})
-	var paths []string
-	if err := traverseVideoPaths(root, root, visited, &paths); err != nil {
-		return nil, err
-	}
-	sort.Strings(paths)
-	return paths, nil
-}
-
-func traverseVideoPaths(displayPath, realPath string, visited map[string]struct{}, acc *[]string) error {
-	resolved, err := filepath.EvalSymlinks(realPath)
-	if err != nil {
-		resolved = realPath
-	}
-	resolved = filepath.Clean(resolved)
-	if _, seen := visited[resolved]; seen {
-		return nil
-	}
-	visited[resolved] = struct{}{}
-
-	entries, err := os.ReadDir(resolved)
-	if err != nil {
-		return err
-	}
-	for _, entry := range entries {
-		displayChild := filepath.Join(displayPath, entry.Name())
-		realChild := filepath.Join(resolved, entry.Name())
-		mode := entry.Type()
-		var info os.FileInfo
-		if mode == fs.FileMode(0) {
-			var err error
-			info, err = entry.Info()
-			if err != nil {
-				return err
-			}
-			mode = info.Mode()
-		}
-		if mode&os.ModeSymlink != 0 {
-			targetPath, err := filepath.EvalSymlinks(realChild)
-			if err != nil {
-				if isVideo(displayChild) {
-					*acc = append(*acc, displayChild)
-				}
-				continue
-			}
-			targetInfo, err := os.Stat(targetPath)
-			if err != nil {
-				if isVideo(displayChild) {
-					*acc = append(*acc, displayChild)
-				}
-				continue
-			}
-			if targetInfo.IsDir() {
-				if err := traverseVideoPaths(displayChild, targetPath, visited, acc); err != nil {
-					return err
-				}
-				continue
-			}
-			if isVideo(displayChild) || isVideo(targetPath) {
-				*acc = append(*acc, displayChild)
-			}
-			continue
-		}
-		if mode.IsDir() {
-			if err := traverseVideoPaths(displayChild, realChild, visited, acc); err != nil {
-				return err
-			}
-			continue
-		}
-		if isVideo(displayChild) {
-			*acc = append(*acc, displayChild)
-		}
-	}
-	return nil
-}
-
-func loadVideos(root string, cache *durationCache, progress *loadProgress) ([]video, []string, error) {
-	paths, err := collectVideoPaths(root)
-	if err != nil {
-		return nil, nil, err
-	}
-	if progress != nil {
-		progress.SetTotal(len(paths))
-	}
-
-	videos := make([]video, 0, len(paths))
-	pending := make([]string, 0)
-	for _, path := range paths {
-		info, statErr := os.Stat(path)
-		if statErr != nil {
-			videos = append(videos, video{Name: filepath.Base(path), Path: path, Err: statErr})
-			if progress != nil {
-				progress.Increment()
-			}
-			continue
-		}
-		var dur time.Duration
-		if cache != nil {
-			if cached, ok := cache.Lookup(path, info); ok {
-				dur = cached
-			} else {
-				pending = append(pending, path)
-			}
-		} else {
-			pending = append(pending, path)
-		}
-		videos = append(videos, video{
-			Name:     filepath.Base(path),
-			Path:     path,
-			Duration: dur,
-			ModTime:  info.ModTime(),
-			Size:     info.Size(),
-			Err:      nil,
-		})
-		if progress != nil {
-			progress.Increment()
-		}
-	}
-
-	return videos, pending, nil
-}
-
-func playVideoCmd(path, crop string) tea.Cmd {
-	return func() tea.Msg {
-		args := []string{}
-		if crop != "" {
-			args = append(args, "--crop", crop)
-		}
-		args = append(args, path)
-		cmd := exec.Command("vlc", args...)
-		if err := cmd.Start(); err != nil {
-			return playVideoMsg{path: path, err: err}
-		}
-		go func() {
-			_ = cmd.Wait()
-		}()
-		return playVideoMsg{path: path}
-	}
-}
-
-func probeDurationsCmd(path string, cache *durationCache) tea.Cmd {
-	return func() tea.Msg {
-		dur, err := probeDuration(path)
-		if err == nil && cache != nil {
-			if info, statErr := os.Stat(path); statErr == nil {
-				_ = cache.Record(path, info, dur)
-			}
-		}
-		return durationUpdateMsg{path: path, duration: dur, err: err}
-	}
-}
-
-func probeDuration(path string) (time.Duration, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path)
-	out, err := cmd.Output()
-	if err != nil {
-		return 0, err
-	}
-	raw := strings.TrimSpace(string(out))
-	if raw == "" {
-		return 0, errors.New("empty duration")
-	}
-	f, err := strconv.ParseFloat(raw, 64)
-	if err != nil {
-		return 0, err
-	}
-	return time.Duration(f * float64(time.Second)), nil
-}
-
-func isVideo(path string) bool {
-	ext := strings.ToLower(filepath.Ext(path))
-	_, ok := videoExtensions[ext]
-	return ok
-}
-
-func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.KeyMsg:
-		return m.handleKeyMsg(msg)
-	case progressUpdateMsg:
-		if m.loading {
-			if msg.total > 0 && !msg.done {
-				m.statusMessage = fmt.Sprintf("Loading videos %d/%d...", msg.processed, msg.total)
-			} else if msg.done {
-				if msg.total == 0 {
-					m.statusMessage = "No videos found"
-				} else {
-					m.statusMessage = fmt.Sprintf("Loaded %d videos", msg.total)
-				}
-			}
-		}
-		if msg.done {
-			return m, nil
-		}
-		return m, progressTickerCmd(m.progress)
-	case durationUpdateMsg:
-		if msg.path != "" {
-			m.updateVideoDuration(msg.path, msg.duration, msg.err)
-			m.durationDone++
-			if msg.err != nil {
-				m.statusMessage = fmt.Sprintf("Duration error for %s: %v", filepath.Base(msg.path), msg.err)
-			} else if m.durationTotal > 0 {
-				m.statusMessage = fmt.Sprintf("Probing durations %d/%d...", m.durationDone, m.durationTotal)
-			}
-		}
-		if m.durationInFlight > 0 {
-			m.durationInFlight--
-		}
-		selectedPath := ""
-		if idx := m.table.Cursor(); idx >= 0 && idx < len(m.filtered) {
-			selectedPath = m.filtered[idx].Path
-		}
-		m.applyFiltersAndSort()
-		if selectedPath != "" {
-			m.restoreSelection(selectedPath)
-		}
-		if m.durationDone >= m.durationTotal && m.durationInFlight == 0 {
-			if m.cache != nil {
-				if err := m.cache.Flush(); err != nil {
-					m.statusMessage = fmt.Sprintf("Duration cache flush error: %v", err)
-				} else {
-					m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
-				}
-			} else {
-				m.statusMessage = fmt.Sprintf("Durations ready (%d videos)", len(m.filtered))
-			}
-			m.pendingDurations = nil
-			m.durationTotal = 0
-			m.durationDone = 0
-			m.durationInFlight = 0
-			return m, nil
-		}
-		if cmd := m.dequeueDurationCmd(); cmd != nil {
-			return m, cmd
-		}
-		return m, nil
-	case videosLoadedMsg:
-		m.loading = false
-		if msg.err != nil {
-			m.err = msg.err
-			m.statusMessage = fmt.Sprintf("error: %v", msg.err)
-		}
-		m.videos = msg.videos
-		m.cache = msg.cache
-		m.pendingDurations = msg.pending
-		m.durationTotal = len(msg.pending)
-		m.durationDone = 0
-		m.applyFiltersAndSort()
-		if len(m.filtered) == 0 {
-			m.statusMessage = "No videos found"
-		} else {
-			if len(msg.pending) > 0 {
-				if msg.cacheErr != nil {
-					m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v), probing durations...", len(m.filtered), msg.cacheErr)
-				} else {
-					m.statusMessage = fmt.Sprintf("Loaded %d videos, probing durations...", len(m.filtered))
-				}
-			} else if msg.cacheErr != nil {
-				m.statusMessage = fmt.Sprintf("Loaded %d videos (cache warning: %v)", len(m.filtered), msg.cacheErr)
-			} else {
-				m.statusMessage = fmt.Sprintf("Loaded %d videos", len(m.filtered))
-			}
-		}
-		m.durationInFlight = 0
-		if len(msg.pending) == 0 {
-			return m, nil
-		}
-		cmd := m.startDurationWorkers()
-		if cmd == nil {
-			return m, nil
-		}
-		return m, cmd
-	case playVideoMsg:
-		if msg.err != nil {
-			m.statusMessage = fmt.Sprintf("Failed to launch VLC: %v", msg.err)
-			return m, nil
-		}
-		m.statusMessage = fmt.Sprintf("Playing via VLC: %s", trimPath(msg.path))
-		return m, nil
-	}
-
-	if m.showFilters {
-		updated, cmd := m.updateFilterInputs(msg)
-		m.inputs = updated
-		return m, cmd
-	}
-
-	tbl, cmd := m.table.Update(msg)
-	m.table = tbl
-	return m, cmd
-}
-
-func (m model) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
-	switch msg.String() {
-	case "ctrl+c", "q":
-		return m, tea.Quit
-	}
-
-	if m.loading {
-		return m, nil
-	}
-
-	if m.showFilters {
-		switch msg.String() {
-		case "esc":
-			m.showFilters = false
-			m.statusMessage = "Filter closed"
-			return m, nil
-		case "enter":
-			if err := m.applyFilterInputs(); err != nil {
-				m.statusMessage = err.Error()
-			} else {
-				m.showFilters = false
-				m.applyFiltersAndSort()
-				m.statusMessage = fmt.Sprintf("Filters applied (%d videos)", len(m.filtered))
-			}
-			return m, nil
-		case "tab":
-			m.inputs.focus = (m.inputs.focus + 1) % len(m.inputs.fields)
-		case "shift+tab":
-			m.inputs.focus = (m.inputs.focus - 1 + len(m.inputs.fields)) % len(m.inputs.fields)
-		default:
-			// no-op; handled below
-		}
-		for i := range m.inputs.fields {
-			if i == m.inputs.focus {
-				m.inputs.fields[i].Focus()
-			} else {
-				m.inputs.fields[i].Blur()
-			}
-		}
-		updated, cmd := m.updateFilterInputs(msg)
-		m.inputs = updated
-		return m, cmd
-	}
-
-	switch msg.String() {
-	case "f":
-		m.showFilters = true
-		m.statusMessage = "Editing filters"
-		return m, nil
-	case "enter":
-		if len(m.filtered) == 0 {
-			return m, nil
-		}
-		idx := m.table.Cursor()
-		if idx < 0 || idx >= len(m.filtered) {
-			return m, nil
-		}
-		vid := m.filtered[idx]
-		m.statusMessage = fmt.Sprintf("Launching VLC: %s", vid.Name)
-		return m, playVideoCmd(vid.Path, m.activeCrop())
-	case "n":
-		m.toggleSort(sortByName)
-	case "l":
-		m.toggleSort(sortByDuration)
-	case "a":
-		m.toggleSort(sortByAge)
-	case "c":
-		if m.cropValue == "" {
-			m.statusMessage = "No crop value set (start with --crop)"
-			return m, nil
-		}
-		m.cropEnabled = !m.cropEnabled
-		if m.cropEnabled {
-			m.statusMessage = fmt.Sprintf("Crop enabled (%s)", m.cropValue)
-		} else {
-			m.statusMessage = "Crop disabled"
-		}
-		return m, nil
-	case "r":
-		m.resetFilters()
-		m.applyFiltersAndSort()
-		m.statusMessage = fmt.Sprintf("Filters cleared (%d videos)", len(m.filtered))
-	default:
-		tbl, cmd := m.table.Update(msg)
-		m.table = tbl
-		return m, cmd
-	}
-
-	m.applyFiltersAndSort()
-	m.statusMessage = fmt.Sprintf("Sorted %d videos", len(m.filtered))
-	return m, nil
-}
-
-func (m model) updateFilterInputs(msg tea.Msg) (filterInputs, tea.Cmd) {
-	inputs := m.inputs
-	var cmds []tea.Cmd
-	for i := range inputs.fields {
-		var cmd tea.Cmd
-		inputs.fields[i], cmd = inputs.fields[i].Update(msg)
-		cmds = append(cmds, cmd)
-	}
-	return inputs, tea.Batch(cmds...)
-}
-
-func (m *model) applyFilterInputs() error {
-	name := strings.TrimSpace(m.inputs.fields[0].Value())
-	minText := strings.TrimSpace(m.inputs.fields[1].Value())
-	maxText := strings.TrimSpace(m.inputs.fields[2].Value())
-
-	filters := filterState{name: name}
-
-	if minText != "" {
-		minVal, err := strconv.Atoi(minText)
-		if err != nil {
-			return fmt.Errorf("invalid min minutes: %q", minText)
-		}
-		if minVal < 0 {
-			return fmt.Errorf("min minutes must be positive")
-		}
-		filters.minEnabled = true
-		filters.minMinutes = minVal
-	}
-
-	if maxText != "" {
-		maxVal, err := strconv.Atoi(maxText)
-		if err != nil {
-			return fmt.Errorf("invalid max minutes: %q", maxText)
-		}
-		if maxVal < 0 {
-			return fmt.Errorf("max minutes must be positive")
-		}
-		filters.maxEnabled = true
-		filters.maxMinutes = maxVal
-	}
-
-	if filters.minEnabled && filters.maxEnabled && filters.minMinutes > filters.maxMinutes {
-		return errors.New("min minutes cannot exceed max minutes")
-	}
-
-	m.filters = filters
-	return nil
-}
-
-func (m *model) resetFilters() {
-	m.filters = filterState{}
-	for i := range m.inputs.fields {
-		m.inputs.fields[i].SetValue("")
-	}
-}
-
-func (m *model) updateVideoDuration(path string, dur time.Duration, err error) {
-	for i := range m.videos {
-		if m.videos[i].Path == path {
-			m.videos[i].Duration = dur
-			if err != nil {
-				m.videos[i].Err = err
-			} else {
-				m.videos[i].Err = nil
-			}
-			break
-		}
-	}
-}
-
-func (m *model) restoreSelection(path string) {
-	for i, v := range m.filtered {
-		if v.Path == path {
-			m.table.SetCursor(i)
-			return
-		}
-	}
-}
-
-func (m model) activeCrop() string {
-	if m.cropEnabled && m.cropValue != "" {
-		return m.cropValue
-	}
-	return ""
-}
-
-func (m *model) dequeueDurationCmd() tea.Cmd {
-	if len(m.pendingDurations) == 0 {
-		return nil
-	}
-	path := m.pendingDurations[0]
-	m.pendingDurations = m.pendingDurations[1:]
-	m.durationInFlight++
-	return probeDurationsCmd(path, m.cache)
-}
-
-func (m *model) startDurationWorkers() tea.Cmd {
-	if len(m.pendingDurations) == 0 {
-		return nil
-	}
-	workers := runtime.NumCPU()
-	if workers < 1 {
-		workers = 1
-	}
-	if workers > 6 {
-		workers = 6
-	}
-	if workers > len(m.pendingDurations) {
-		workers = len(m.pendingDurations)
-	}
-	cmds := make([]tea.Cmd, 0, workers)
-	for i := 0; i < workers; i++ {
-		if cmd := m.dequeueDurationCmd(); cmd != nil {
-			cmds = append(cmds, cmd)
-		}
-	}
-	if len(cmds) == 0 {
-		return nil
-	}
-	return tea.Batch(cmds...)
-}
-
-func (m *model) toggleSort(target sortField) {
-	if m.sortField == target {
-		m.sortAscending = !m.sortAscending
-	} else {
-		m.sortField = target
-		m.sortAscending = true
-	}
-}
-
-func (m *model) applyFiltersAndSort() {
-	filtered := make([]video, 0, len(m.videos))
-	for _, v := range m.videos {
-		if !m.passesFilters(v) {
-			continue
-		}
-		filtered = append(filtered, v)
-	}
-
-	sort.Slice(filtered, func(i, j int) bool {
-		a, b := filtered[i], filtered[j]
-		less := false
-		switch m.sortField {
-		case sortByName:
-			less = strings.ToLower(a.Name) < strings.ToLower(b.Name)
-		case sortByDuration:
-			less = a.Duration < b.Duration
-		case sortByAge:
-			less = a.ModTime.Before(b.ModTime)
-		}
-		if m.sortAscending {
-			return less
-		}
-		return !less
-	})
-
-	m.filtered = filtered
-	rows := make([]table.Row, 0, len(filtered))
-	for _, v := range filtered {
-		rows = append(rows, videoRow(v))
-	}
-	m.table.SetRows(rows)
-	if len(rows) > 0 {
-		m.table.SetCursor(0)
-	}
-}
-
-func (m model) passesFilters(v video) bool {
-	f := m.filters
-	if f.name != "" && !strings.Contains(strings.ToLower(v.Name), strings.ToLower(f.name)) {
-		return false
-	}
-	durMinutes := int(v.Duration.Round(time.Minute) / time.Minute)
-	if f.minEnabled && (v.Duration == 0 || durMinutes < f.minMinutes) {
-		return false
-	}
-	if f.maxEnabled && (v.Duration == 0 || durMinutes > f.maxMinutes) {
-		return false
-	}
-	return true
-}
-
-func videoRow(v video) table.Row {
-	duration := "(unknown)"
-	if v.Duration > 0 {
-		duration = formatDuration(v.Duration)
-	}
-	age := humanizeAge(v.ModTime)
-	path := trimPath(v.Path)
-	if v.Err != nil {
-		duration = "!" + v.Err.Error()
-	}
-	return table.Row{v.Name, duration, age, path}
-}
-
-func renderProgressBar(done, total, width int) string {
-	if width <= 0 || total <= 0 {
-		return ""
-	}
-	if done < 0 {
-		done = 0
-	}
-	if done > total {
-		done = total
-	}
-	filled := int(float64(done) / float64(total) * float64(width))
-	if filled > width {
-		filled = width
-	}
-	bar := strings.Repeat("#", filled) + strings.Repeat("-", width-filled)
-	return fmt.Sprintf("[%s]", bar)
-}
-
-func formatDuration(d time.Duration) string {
-	if d <= 0 {
-		return "--"
-	}
-	totalSeconds := int(d.Seconds() + 0.5)
-	hours := totalSeconds / 3600
-	minutes := (totalSeconds % 3600) / 60
-	seconds := totalSeconds % 60
-	if hours > 0 {
-		return fmt.Sprintf("%d:%02d:%02d", hours, minutes, seconds)
-	}
-	return fmt.Sprintf("%02d:%02d", minutes, seconds)
-}
-
-func humanizeAge(t time.Time) string {
-	if t.IsZero() {
-		return "--"
-	}
-	now := time.Now()
-	dur := now.Sub(t)
-	if dur < time.Minute {
-		return "just now"
-	}
-	if dur < time.Hour {
-		return fmt.Sprintf("%dm ago", int(dur.Minutes()))
-	}
-	if dur < 24*time.Hour {
-		return fmt.Sprintf("%dh ago", int(dur.Hours()))
-	}
-	return t.Format("2006-01-02")
-}
-
-func trimPath(path string) string {
-	home, err := os.UserHomeDir()
-	if err == nil {
-		if strings.HasPrefix(path, home) {
-			return "~" + strings.TrimPrefix(path, home)
-		}
-	}
-	return path
-}
-
-func (m model) View() string {
-	if m.loading {
-		return statusStyle.Render("Loading videos, please wait...")
-	}
-
-	if m.err != nil && len(m.filtered) == 0 {
-		return statusStyle.Render(fmt.Sprintf("Failed to load videos: %v", m.err))
-	}
-
-	cropHelp := "Crop: (no crop configured; start with --crop)"
-	if m.cropValue != "" {
-		state := "off"
-		if m.cropEnabled {
-			state = "on"
-		}
-		cropHelp = fmt.Sprintf("Crop: c=toggle (%s %s)", state, m.cropValue)
-	}
-	helpLines := []string{
-		"Controls: ↑/↓ move • Enter selects (noop) • q quits",
-		"Sorting: n=name • l=length • a=age • r=reset filters",
-		"Filters: f=toggle filter editor (tab to navigate, enter to apply, esc to cancel)",
-		cropHelp,
-	}
-	info := statusStyle.Render(m.statusMessage)
-
-	progressLine := ""
-	if m.durationTotal > 0 {
-		bar := renderProgressBar(m.durationDone, m.durationTotal, 24)
-		progressLine = statusStyle.Render(fmt.Sprintf("Duration scan %s %d/%d", bar, m.durationDone, m.durationTotal))
-	}
-
-	content := tableStyle.Render(m.table.View())
-	help := strings.Join(helpLines, "\n")
-
-	var parts []string
-	parts = append(parts, content)
-	if progressLine != "" {
-		parts = append(parts, progressLine)
-	}
-	parts = append(parts, info, help)
-	body := strings.Join(parts, "\n")
-
-	if m.showFilters {
-		return body + "\n\n" + m.renderFilterModal()
-	}
-
-	return body
-}
-
-func (m model) renderFilterModal() string {
-	var b strings.Builder
-	b.WriteString("Filter videos\n")
-	b.WriteString("(Enter to apply, Esc to cancel)\n\n")
-	labels := []string{"Name contains:", "Min length (minutes):", "Max length (minutes):"}
-	for i, field := range m.inputs.fields {
-		line := fmt.Sprintf("%s %s", labels[i], field.View())
-		if i == m.inputs.focus {
-			line = highlightStyle.Render(line)
-		}
-		b.WriteString(line)
-		b.WriteString("\n")
-	}
-	if m.filters.minEnabled || m.filters.maxEnabled || m.filters.name != "" {
-		b.WriteString("\nCurrent filter: ")
-		b.WriteString(m.describeFilters())
-		b.WriteString("\n")
-	}
-	return filterStyle.Render(b.String())
-}
-
-func (m model) describeFilters() string {
-	parts := []string{}
-	if m.filters.name != "" {
-		parts = append(parts, fmt.Sprintf("name contains %q", m.filters.name))
-	}
-	if m.filters.minEnabled {
-		parts = append(parts, fmt.Sprintf(">=%d min", m.filters.minMinutes))
-	}
-	if m.filters.maxEnabled {
-		parts = append(parts, fmt.Sprintf("<=%d min", m.filters.maxMinutes))
-	}
-	if len(parts) == 0 {
-		return "(none)"
-	}
-	return strings.Join(parts, ", ")
-}
diff --git a/main_test.go b/main_test.go
deleted file mode 100644
index 741311c..0000000
--- a/main_test.go
+++ /dev/null
@@ -1,119 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-func TestLoadVideosDetectsMP4(t *testing.T) {
-	dir := t.TempDir()
-	videoPath := filepath.Join(dir, "video.mp4")
-	if err := os.WriteFile(videoPath, []byte("dummy"), 0o644); err != nil {
-		t.Fatalf("failed to create test video: %v", err)
-	}
-	upperPath := filepath.Join(dir, "UPPER.MP4")
-	if err := os.WriteFile(upperPath, []byte("dummy"), 0o644); err != nil {
-		t.Fatalf("failed to create upper test video: %v", err)
-	}
-
-	vids, pending, err := loadVideos(dir, nil, nil)
-	if err != nil {
-		t.Fatalf("loadVideos returned error: %v", err)
-	}
-	if len(vids) != 2 {
-		t.Fatalf("expected 2 videos, got %d", len(vids))
-	}
-	paths := map[string]bool{videoPath: false, upperPath: false}
-	for _, v := range vids {
-		if _, ok := paths[v.Path]; ok {
-			paths[v.Path] = true
-		}
-	}
-	for p, seen := range paths {
-		if !seen {
-			t.Fatalf("missing video %s", p)
-		}
-	}
-	if len(pending) != 2 {
-		t.Fatalf("expected pending durations for both videos, got %d", len(pending))
-	}
-}
-
-func TestLoadVideosFollowSymlinkDirectories(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("symlink permissions vary on Windows")
-	}
-
-	root := t.TempDir()
-	storage := t.TempDir()
-
-	if err := os.WriteFile(filepath.Join(storage, "movie.mp4"), []byte("dummy"), 0o644); err != nil {
-		t.Fatalf("failed to create storage video: %v", err)
-	}
-
-	linkPath := filepath.Join(root, "videos")
-	if err := os.Symlink(storage, linkPath); err != nil {
-		t.Skipf("symlink not supported: %v", err)
-	}
-
-	vids, _, err := loadVideos(root, nil, nil)
-	if err != nil {
-		t.Fatalf("loadVideos returned error: %v", err)
-	}
-
-	expected := filepath.Join(linkPath, "movie.mp4")
-	found := false
-	for _, v := range vids {
-		if v.Path == expected {
-			found = true
-			break
-		}
-	}
-	if !found {
-		t.Fatalf("expected to find video at %s, paths=%v", expected, vids)
-	}
-}
-
-func TestResolveRootPathDefaultCreatesDirectory(t *testing.T) {
-	tmp := t.TempDir()
-	t.Setenv("HOME", tmp)
-
-	got, err := resolveRootPath("")
-	if err != nil {
-		t.Fatalf("resolveRootPath returned error: %v", err)
-	}
-	want := filepath.Join(tmp, "Yoga")
-	if got != want {
-		t.Fatalf("expected %s, got %s", want, got)
-	}
-	info, err := os.Stat(want)
-	if err != nil {
-		t.Fatalf("stat expected dir failed: %v", err)
-	}
-	if !info.IsDir() {
-		t.Fatalf("expected %s to be a directory", want)
-	}
-}
-
-func TestResolveRootPathRequiresExistingDirectory(t *testing.T) {
-	tmp := t.TempDir()
-	missing := filepath.Join(tmp, "missing")
-	if _, err := resolveRootPath(missing); err == nil {
-		t.Fatalf("expected error for missing path %s", missing)
-	}
-}
-
-func TestExpandPathHome(t *testing.T) {
-	tmp := t.TempDir()
-	t.Setenv("HOME", tmp)
-	got, err := expandPath("~/custom")
-	if err != nil {
-		t.Fatalf("expandPath error: %v", err)
-	}
-	want := filepath.Join(tmp, "custom")
-	if got != want {
-		t.Fatalf("expected %s, got %s", want, got)
-	}
-}