20 files changed, 2115 insertions, 0 deletions
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
+}