gora-cli 0.1.2__py3-none-any.whl

gora/go_tui/main.go

@@ -0,0 +1,2634 @@
+package main
+
+import (
+	"database/sql"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/list"
+	"github.com/charmbracelet/bubbles/table"
+	"github.com/charmbracelet/bubbles/textinput"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+	_ "modernc.org/sqlite"
+)
+
+var (
+	bg      = lipgloss.Color("#1a1b26")
+	surface = lipgloss.Color("#1f2335")
+	fg      = lipgloss.Color("#c0caf5")
+	muted   = lipgloss.Color("#565f89")
+	border  = lipgloss.Color("#3b4261")
+	cyan    = lipgloss.Color("#7dcfff")
+	purple  = lipgloss.Color("#bb9af7")
+	green   = lipgloss.Color("#9ece6a")
+	yellow  = lipgloss.Color("#e0af68")
+	red     = lipgloss.Color("#f7768e")
+
+	baseStyle     = lipgloss.NewStyle().Foreground(fg).Background(bg)
+	mutedStyle    = lipgloss.NewStyle().Foreground(muted).Background(bg)
+	sectionStyle  = lipgloss.NewStyle().Foreground(cyan).Background(bg).Bold(true)
+	selectedStyle = lipgloss.NewStyle().Foreground(fg).Background(bg).Bold(true)
+	searchStyle   = lipgloss.NewStyle().Foreground(fg).Background(surface).Border(lipgloss.NormalBorder()).BorderForeground(border).Padding(0, 1)
+	searchText    = lipgloss.NewStyle().Foreground(fg).Background(surface)
+	searchHint    = lipgloss.NewStyle().Foreground(muted).Background(surface)
+	searchCursor  = lipgloss.NewStyle().Foreground(bg).Background(yellow)
+
+	imageTagPattern = regexp.MustCompile(`(?s)</?image\b[^>]*(>|$)`)
+)
+
+type item struct {
+	SessionKey   string
+	Provider     string
+	Title        string
+	Timestamp    string
+	CreatedAt    string
+	UpdatedAt    string
+	Cwd          string
+	Models       string
+	Preview      string
+	MessageCount int
+	Ordinal      int
+	IsMatch      bool
+}
+
+type focusArea int
+
+const (
+	focusSearch focusArea = iota
+	focusFilters
+	focusResults
+)
+
+type filterSection int
+
+const (
+	sectionHarness filterSection = iota
+	sectionRepos
+	sectionModels
+	sectionRoles
+	filterSectionCount
+)
+
+type filterOption struct {
+	Value string
+	Label string
+	Count int
+}
+
+type filterListItem struct {
+	option      filterOption
+	selected    bool
+	section     filterSection
+	description string
+}
+
+func (i filterListItem) FilterValue() string {
+	return i.option.Label + " " + i.option.Value
+}
+
+func (i filterListItem) Title() string {
+	check := "[ ]"
+	if i.selected {
+		check = "[x]"
+	}
+	label := i.option.Label
+	if i.section == sectionRepos {
+		label = shortCwd(i.option.Value)
+	}
+	return check + " " + label
+}
+
+func (i filterListItem) Description() string {
+	if i.description != "" {
+		return i.description
+	}
+	if i.option.Count > 0 {
+		return fmt.Sprintf("%d chats", i.option.Count)
+	}
+	return i.option.Value
+}
+
+type transcriptMessage struct {
+	Role      string
+	Timestamp string
+	Model     string
+	Text      string
+}
+
+type actionKind int
+
+const (
+	actionNone actionKind = iota
+	actionOpen
+	actionBack
+	actionExportMarkdown
+	actionExportText
+	actionFilters
+)
+
+type actionButton struct {
+	Label  string
+	Action actionKind
+	X      int
+	Y      int
+	Width  int
+}
+
+type keySet struct {
+	short []key.Binding
+	full  [][]key.Binding
+}
+
+func (k keySet) ShortHelp() []key.Binding {
+	return k.short
+}
+
+func (k keySet) FullHelp() [][]key.Binding {
+	return k.full
+}
+
+type keyMap struct {
+	Open           key.Binding
+	Back           key.Binding
+	ExportMarkdown key.Binding
+	ExportText     key.Binding
+	Filter         key.Binding
+	FilterHarness  key.Binding
+	FilterRepos    key.Binding
+	FilterModels   key.Binding
+	FilterRoles    key.Binding
+	AdvanceFilter  key.Binding
+	Search         key.Binding
+	Focus          key.Binding
+	Move           key.Binding
+	Select         key.Binding
+	Clear          key.Binding
+	ClearSection   key.Binding
+	Apply          key.Binding
+	Quit           key.Binding
+}
+
+func newKeyMap() keyMap {
+	return keyMap{
+		Open: key.NewBinding(
+			key.WithKeys("enter", "right"),
+			key.WithHelp("enter", "open"),
+		),
+		Back: key.NewBinding(
+			key.WithKeys("esc", "left"),
+			key.WithHelp("esc/left", "back"),
+		),
+		ExportMarkdown: key.NewBinding(
+			key.WithKeys("m"),
+			key.WithHelp("m", "export md"),
+		),
+		ExportText: key.NewBinding(
+			key.WithKeys("t"),
+			key.WithHelp("t", "export txt"),
+		),
+		Filter: key.NewBinding(
+			key.WithKeys("ctrl+f", "enter"),
+			key.WithHelp("ctrl+f", "filters"),
+		),
+		FilterHarness: key.NewBinding(
+			key.WithKeys("1", "h"),
+			key.WithHelp("1/h", "harness"),
+		),
+		FilterRepos: key.NewBinding(
+			key.WithKeys("2", "r"),
+			key.WithHelp("2/r", "repos"),
+		),
+		FilterModels: key.NewBinding(
+			key.WithKeys("3", "m"),
+			key.WithHelp("3/m", "models"),
+		),
+		FilterRoles: key.NewBinding(
+			key.WithKeys("4", "o"),
+			key.WithHelp("4/o", "roles"),
+		),
+		AdvanceFilter: key.NewBinding(
+			key.WithKeys("enter"),
+			key.WithHelp("enter", "select + next"),
+		),
+		Search: key.NewBinding(
+			key.WithKeys("/"),
+			key.WithHelp("/", "search"),
+		),
+		Focus: key.NewBinding(
+			key.WithKeys("tab", "shift+tab"),
+			key.WithHelp("tab", "focus"),
+		),
+		Move: key.NewBinding(
+			key.WithKeys("up", "down", "k", "j", "pgup", "pgdown"),
+			key.WithHelp("↑/↓", "move"),
+		),
+		Select: key.NewBinding(
+			key.WithKeys(" ", "enter"),
+			key.WithHelp("space", "select"),
+		),
+		Clear: key.NewBinding(
+			key.WithKeys("ctrl+u"),
+			key.WithHelp("ctrl+u", "clear"),
+		),
+		ClearSection: key.NewBinding(
+			key.WithKeys("c"),
+			key.WithHelp("c", "clear section"),
+		),
+		Apply: key.NewBinding(
+			key.WithKeys("esc", "left"),
+			key.WithHelp("esc", "apply"),
+		),
+		Quit: key.NewBinding(
+			key.WithKeys("ctrl+c", "q"),
+			key.WithHelp("ctrl+c", "quit"),
+		),
+	}
+}
+
+func newHelpModel() help.Model {
+	model := help.New()
+	model.ShortSeparator = "  "
+	model.FullSeparator = "    "
+	model.Styles.ShortKey = lipgloss.NewStyle().Foreground(cyan).Background(bg).Bold(true)
+	model.Styles.ShortDesc = lipgloss.NewStyle().Foreground(muted).Background(bg)
+	model.Styles.ShortSeparator = lipgloss.NewStyle().Foreground(border).Background(bg)
+	model.Styles.FullKey = model.Styles.ShortKey
+	model.Styles.FullDesc = model.Styles.ShortDesc
+	model.Styles.FullSeparator = model.Styles.ShortSeparator
+	model.Styles.Ellipsis = lipgloss.NewStyle().Foreground(muted).Background(bg)
+	return model
+}
+
+func newResultsTable() table.Model {
+	model := table.New(table.WithFocused(false), table.WithHeight(12), table.WithWidth(80))
+	model.SetStyles(resultsTableStyles())
+	return model
+}
+
+func resultsTableStyles() table.Styles {
+	styles := table.DefaultStyles()
+	styles.Header = lipgloss.NewStyle().
+		Foreground(cyan).
+		Background(bg).
+		Bold(true).
+		Padding(0, 1).
+		BorderStyle(lipgloss.NormalBorder()).
+		BorderForeground(border).
+		BorderBottom(true)
+	styles.Cell = lipgloss.NewStyle().
+		Foreground(fg).
+		Background(bg).
+		Padding(0, 1)
+	styles.Selected = lipgloss.NewStyle().
+		Foreground(fg).
+		Background(surface).
+		Bold(true)
+	return styles
+}
+
+func newFilterList(width int, height int) list.Model {
+	delegate := list.NewDefaultDelegate()
+	delegate.SetHeight(2)
+	delegate.SetSpacing(0)
+	delegate.Styles.NormalTitle = lipgloss.NewStyle().Foreground(fg).Background(bg).Padding(0, 0, 0, 2)
+	delegate.Styles.NormalDesc = lipgloss.NewStyle().Foreground(muted).Background(bg).Padding(0, 0, 0, 2)
+	delegate.Styles.SelectedTitle = lipgloss.NewStyle().
+		Foreground(bg).
+		Background(cyan).
+		Bold(true).
+		Padding(0, 1)
+	delegate.Styles.SelectedDesc = lipgloss.NewStyle().
+		Foreground(fg).
+		Background(surface).
+		Padding(0, 1)
+	delegate.Styles.DimmedTitle = mutedStyle.Padding(0, 0, 0, 2)
+	delegate.Styles.DimmedDesc = mutedStyle.Padding(0, 0, 0, 2)
+	delegate.Styles.FilterMatch = lipgloss.NewStyle().Foreground(yellow).Bold(true)
+
+	model := list.New(nil, delegate, width, height)
+	model.SetShowHelp(false)
+	model.SetShowFilter(false)
+	model.SetFilteringEnabled(false)
+	model.SetShowStatusBar(true)
+	model.SetShowPagination(true)
+	model.SetStatusBarItemName("option", "options")
+	model.DisableQuitKeybindings()
+	model.Styles.Title = lipgloss.NewStyle().Foreground(cyan).Background(bg).Bold(true)
+	model.Styles.StatusBar = lipgloss.NewStyle().Foreground(muted).Background(bg)
+	model.Styles.PaginationStyle = lipgloss.NewStyle().Foreground(muted).Background(bg)
+	model.Styles.HelpStyle = mutedStyle
+	return model
+}
+
+type model struct {
+	db              *sql.DB
+	dbPath          string
+	search          textinput.Model
+	transcriptView  viewport.Model
+	helpBubble      help.Model
+	resultsTable    table.Model
+	filterList      list.Model
+	keys            keyMap
+	providers       map[string]bool
+	repoFilters     map[string]bool
+	modelFilters    map[string]bool
+	providerOptions []filterOption
+	repoOptions     []filterOption
+	modelOptions    []filterOption
+	allRoles        bool
+	detail          bool
+	detailItem      item
+	filterOpen      bool
+	focus           focusArea
+	filterSection   filterSection
+	previewKey      string
+	previewWidth    int
+	previewAllRoles bool
+	previewLines    []string
+	previewErr      error
+	selected        int
+	width           int
+	height          int
+	searchTop       int
+	searchBottom    int
+	filterTop       int
+	filterBottom    int
+	rowsTop         int
+	browseButtons   []actionButton
+	detailButtons   []actionButton
+	results         []item
+	notice          string
+	err             error
+}
+
+func main() {
+	configureTerminalColors()
+
+	dbPath := flag.String("db", "", "SQLite index path")
+	flag.Parse()
+
+	path := *dbPath
+	if path == "" {
+		path = defaultDBPath()
+	}
+
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "open database: %v\n", err)
+		os.Exit(1)
+	}
+	defer db.Close()
+	db.SetMaxOpenConns(1)
+
+	search := textinput.New()
+	search.Placeholder = "type to search local Codex, Claude Code, and Pi chats"
+	search.Prompt = ""
+	search.Focus()
+	search.CharLimit = 512
+	search.PlaceholderStyle = mutedStyle
+	search.TextStyle = baseStyle
+	search.Cursor.Style = lipgloss.NewStyle().Foreground(yellow).Background(bg)
+
+	m := &model{
+		db:             db,
+		dbPath:         path,
+		search:         search,
+		transcriptView: viewport.New(80, 20),
+		helpBubble:     newHelpModel(),
+		resultsTable:   newResultsTable(),
+		filterList:     newFilterList(80, 20),
+		keys:           newKeyMap(),
+		providers:      map[string]bool{},
+		repoFilters:    map[string]bool{},
+		modelFilters:   map[string]bool{},
+		allRoles:       true,
+	}
+	m.providerOptions, _ = loadProviderOptions(db)
+	m.repoOptions, _ = loadRepoOptions(db)
+	m.modelOptions, _ = loadModelOptions(db)
+	m.reload()
+
+	program := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
+	if _, err := program.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "run tui: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func configureTerminalColors() {
+	if os.Getenv("GORA_NO_COLOR") == "1" {
+		return
+	}
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	lipgloss.SetHasDarkBackground(true)
+}
+
+func (m *model) Init() tea.Cmd {
+	return textinput.Blink
+}
+
+func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+		m.helpBubble.Width = msg.Width
+		m.search.Width = max(10, msg.Width-8)
+		m.transcriptView.Width = max(20, msg.Width-2)
+		m.transcriptView.Height = m.detailHeight()
+		m.configureResultsTable(max(72, msg.Width), max(4, msg.Height/2))
+		m.configureFilterList(max(72, msg.Width), max(8, msg.Height-8))
+	case tea.KeyMsg:
+		return m, m.handleKey(msg)
+	case tea.MouseMsg:
+		return m, m.handleMouse(msg)
+	}
+	return m, nil
+}
+
+func (m *model) handleKey(msg tea.KeyMsg) tea.Cmd {
+	key := msg.String()
+	if m.filterOpen {
+		return m.handleFilterKey(msg)
+	}
+	if m.detail {
+		switch key {
+		case "esc", "left":
+			m.detail = false
+		case "ctrl+c", "q":
+			return tea.Quit
+		case "m":
+			m.exportSelected("md")
+		case "t":
+			m.exportSelected("txt")
+		default:
+			var cmd tea.Cmd
+			m.transcriptView, cmd = m.transcriptView.Update(msg)
+			return cmd
+		}
+		return nil
+	}
+
+	switch key {
+	case "ctrl+c":
+		return tea.Quit
+	case "esc":
+		if m.search.Value() != "" {
+			m.search.SetValue("")
+			m.resetPosition()
+			m.reload()
+			return nil
+		}
+		if m.hasActiveFilters() {
+			m.clearFilters()
+			m.notice = "filters cleared"
+			m.resetPosition()
+			m.reload()
+			return nil
+		}
+		return tea.Quit
+	case "tab":
+		m.nextFocus()
+	case "shift+tab":
+		m.previousFocus()
+	case "ctrl+f":
+		m.setFocus(focusFilters)
+		m.openFilters()
+	case "/":
+		m.setFocus(focusSearch)
+	case "up", "k":
+		m.move(-1)
+		m.setFocus(focusResults)
+	case "down", "j":
+		m.move(1)
+		m.setFocus(focusResults)
+	case "pgup":
+		m.move(-10)
+		m.setFocus(focusResults)
+	case "pgdown":
+		m.move(10)
+		m.setFocus(focusResults)
+	case "enter", "right":
+		if m.focus == focusFilters {
+			m.openFilters()
+			return nil
+		}
+		if len(m.results) > 0 {
+			m.setFocus(focusResults)
+			m.openDetail()
+		}
+	case "ctrl+r":
+		m.allRoles = !m.allRoles
+		m.resetPosition()
+		m.reload()
+	case "ctrl+u":
+		m.search.SetValue("")
+		m.resetPosition()
+		m.reload()
+	default:
+		if m.focus != focusSearch {
+			if key == "m" {
+				m.exportSelected("md")
+			}
+			if key == "t" {
+				m.exportSelected("txt")
+			}
+			return nil
+		}
+		before := m.search.Value()
+		var cmd tea.Cmd
+		m.search, cmd = m.search.Update(msg)
+		if m.search.Value() != before {
+			m.resetPosition()
+			m.reload()
+		}
+		return cmd
+	}
+	return nil
+}
+
+func (m *model) handleMouse(msg tea.MouseMsg) tea.Cmd {
+	if m.detail {
+		if msg.Button == tea.MouseButtonLeft && msg.Action == tea.MouseActionPress {
+			if action := buttonActionAt(m.detailButtons, msg.X, msg.Y); action != actionNone {
+				m.performAction(action)
+				return nil
+			}
+		}
+		var cmd tea.Cmd
+		m.transcriptView, cmd = m.transcriptView.Update(msg)
+		return cmd
+	}
+	if msg.Button == tea.MouseButtonWheelUp {
+		m.move(-3)
+		m.setFocus(focusResults)
+		return nil
+	}
+	if msg.Button == tea.MouseButtonWheelDown {
+		m.move(3)
+		m.setFocus(focusResults)
+		return nil
+	}
+	if msg.Button != tea.MouseButtonLeft || msg.Action != tea.MouseActionPress {
+		return nil
+	}
+	if m.filterOpen {
+		m.handleFilterClick(msg)
+		return nil
+	}
+	if action := buttonActionAt(m.browseButtons, msg.X, msg.Y); action != actionNone {
+		m.performAction(action)
+		return nil
+	}
+	switch {
+	case msg.Y >= m.searchTop && msg.Y <= m.searchBottom:
+		m.setFocus(focusSearch)
+	case msg.Y >= m.filterTop && msg.Y <= m.filterBottom:
+		m.setFocus(focusFilters)
+		m.openFilters()
+	case msg.Y >= m.rowsTop:
+		m.setFocus(focusResults)
+	}
+	return nil
+}
+
+func (m *model) performAction(action actionKind) {
+	switch action {
+	case actionOpen:
+		if len(m.results) > 0 {
+			m.setFocus(focusResults)
+			m.openDetail()
+		}
+	case actionBack:
+		m.detail = false
+	case actionExportMarkdown:
+		m.exportSelected("md")
+	case actionExportText:
+		m.exportSelected("txt")
+	case actionFilters:
+		m.setFocus(focusFilters)
+		m.openFilters()
+	}
+}
+
+func buttonActionAt(buttons []actionButton, x int, y int) actionKind {
+	for _, button := range buttons {
+		if y == button.Y && x >= button.X && x < button.X+button.Width {
+			return button.Action
+		}
+	}
+	return actionNone
+}
+
+func (m *model) setFocus(focus focusArea) {
+	m.focus = focus
+	if focus == focusSearch {
+		m.search.Focus()
+		m.resultsTable.Blur()
+		return
+	}
+	m.search.Blur()
+	if focus == focusResults {
+		m.resultsTable.Focus()
+		return
+	}
+	m.resultsTable.Blur()
+}
+
+func (m *model) nextFocus() {
+	switch m.focus {
+	case focusSearch:
+		m.setFocus(focusFilters)
+	case focusFilters:
+		m.setFocus(focusResults)
+	default:
+		m.setFocus(focusSearch)
+	}
+}
+
+func (m *model) previousFocus() {
+	switch m.focus {
+	case focusSearch:
+		m.setFocus(focusResults)
+	case focusFilters:
+		m.setFocus(focusSearch)
+	default:
+		m.setFocus(focusFilters)
+	}
+}
+
+func (m *model) View() string {
+	if m.width == 0 || m.height == 0 {
+		return ""
+	}
+	if m.filterOpen {
+		return m.filterView()
+	}
+	if m.detail {
+		return m.detailView()
+	}
+	return m.browseView()
+}
+
+func (m *model) browseView() string {
+	width := max(72, m.width)
+	searchBlock := m.renderSearch(width)
+	filterBlock := m.renderFilters(width)
+	statusBlock := m.renderStatus(width)
+	m.searchTop = 0
+	m.searchBottom = lipgloss.Height(searchBlock) - 1
+	m.filterTop = m.searchBottom + 1
+	m.filterBottom = m.filterTop + lipgloss.Height(filterBlock) - 1
+	m.rowsTop = m.filterBottom + lipgloss.Height(statusBlock) + 2
+
+	lines := []string{searchBlock, filterBlock, statusBlock}
+	footer := m.renderFooter(width)
+	bodyHeight := max(6, m.height-lipgloss.Height(strings.Join(lines, "\n"))-lipgloss.Height(footer)-2)
+	lines = append(lines, m.renderBrowseBody(width, bodyHeight))
+	actionY := lipgloss.Height(strings.Join(lines, "\n"))
+	lines = append(lines, m.renderBrowseActions(width, actionY))
+	lines = append(lines, footer)
+	return baseStyle.Width(width).Height(m.height).Render(strings.Join(lines, "\n"))
+}
+
+func (m *model) renderBrowseBody(width int, height int) string {
+	if width >= 104 && len(m.results) > 0 {
+		gap := 2
+		rightWidth := clamp(width/3, 38, 52)
+		leftWidth := max(48, width-rightWidth-gap)
+		leftTitle := m.renderResultsTitle(leftWidth)
+		left := strings.Join([]string{
+			leftTitle,
+			m.renderResultsTable(leftWidth, max(4, height-lipgloss.Height(leftTitle))),
+		}, "\n")
+		right := m.renderSelectedPreview(rightWidth, height)
+		return lipgloss.JoinHorizontal(lipgloss.Top, left, baseStyle.Render(strings.Repeat(" ", gap)), right)
+	}
+
+	title := m.renderResultsTitle(width)
+	tableHeight := max(4, height-lipgloss.Height(title)-5)
+	preview := m.renderSelectedPreview(width, max(4, height-lipgloss.Height(title)-tableHeight))
+	return strings.Join([]string{title, m.renderResultsTable(width, tableHeight), preview}, "\n")
+}
+
+func (m *model) renderSearch(width int) string {
+	contentWidth := max(20, width-8)
+	m.search.Width = contentWidth
+	style := searchStyle
+	if m.focus == focusSearch {
+		style = style.BorderForeground(cyan)
+	}
+	return style.Width(contentWidth).Render(m.renderSearchInput(contentWidth))
+}
+
+func (m *model) renderSearchInput(width int) string {
+	value := m.search.Value()
+	if value == "" {
+		return searchHint.Render(padRight(m.search.Placeholder, width))
+	}
+	if m.focus != focusSearch {
+		return searchText.Render(padRight(fit(value, width), width))
+	}
+
+	runes := []rune(value)
+	position := clamp(m.search.Position(), 0, len(runes))
+	start := 0
+	if position >= width {
+		start = position - width + 1
+	}
+	end := min(len(runes), start+width)
+	visible := runes[start:end]
+	cursor := position - start
+
+	if len(visible) >= width && cursor >= width {
+		visible = visible[:width-1]
+		cursor = width - 1
+	}
+
+	before := string(visible[:min(cursor, len(visible))])
+	cursorChar := " "
+	after := ""
+	if cursor < len(visible) {
+		cursorChar = string(visible[cursor])
+		after = string(visible[cursor+1:])
+	}
+
+	rendered := searchText.Render(before) + searchCursor.Render(cursorChar) + searchText.Render(after)
+	return rendered + searchText.Render(strings.Repeat(" ", max(0, width-lipgloss.Width(rendered))))
+}
+
+func (m *model) renderFilters(width int) string {
+	provider := m.compactProviderSummary()
+	modelName := m.compactModelSummary()
+	repo := m.compactRepoSummary()
+	roles := "user+assistant"
+	if m.allRoles {
+		roles = "all roles"
+	}
+
+	title := sectionStyle.Render("Filters")
+	if m.focus == focusFilters {
+		title = selectedStyle.Foreground(cyan).Render("Filters")
+	}
+	action := renderFilterAction(m.keys.Filter, m.focus == focusFilters)
+	help := mutedStyle.Render("Tab focus  Enter edit  1/2/3/4 inside editor")
+	top := lipgloss.JoinHorizontal(lipgloss.Center, title, baseStyle.Render("  "), action, baseStyle.Render("  "), help)
+	if lipgloss.Width(top) > width {
+		top = lipgloss.JoinHorizontal(lipgloss.Center, title, baseStyle.Render("  "), action)
+	}
+
+	chips := []string{
+		filterControl("Harness", provider, len(m.providers) > 0, purple),
+		filterControl("Repo", repo, len(m.repoFilters) > 0, green),
+		filterControl("Model", modelName, len(m.modelFilters) > 0, yellow),
+		filterControl("Roles", roles, !m.allRoles, cyan),
+	}
+	return top + "\n" + joinFilterControls(chips, width)
+}
+
+func (m *model) renderStatus(width int) string {
+	if m.search.Value() != "" {
+		status := fmt.Sprintf("%d matches for %q", len(m.results), m.search.Value())
+		return m.renderStatusLine(status, width)
+	}
+	return m.renderStatusLine(fmt.Sprintf("%d recent chats", len(m.results)), width)
+}
+
+func (m *model) renderStatusLine(status string, width int) string {
+	if m.notice != "" {
+		status += "  " + m.notice
+	}
+	if m.err != nil {
+		status += "  " + m.err.Error()
+	}
+	return mutedStyle.Render(fit(status, width))
+}
+
+func (m *model) renderResultsTitle(width int) string {
+	count := fmt.Sprintf("%d chats", len(m.results))
+	title := sectionStyle.Render("found chats")
+	spacer := mutedStyle.Render(strings.Repeat(" ", max(1, width-lipgloss.Width(title)-lipgloss.Width(count))))
+	return title + spacer + mutedStyle.Render(count)
+}
+
+func (m *model) renderResultsTable(width int, height int) string {
+	if len(m.results) == 0 {
+		if m.hasActiveFilters() {
+			return mutedStyle.Render("  no chats match the current filters")
+		}
+		if m.search.Value() == "" {
+			return mutedStyle.Render("  no sessions indexed; run gora import")
+		}
+		return mutedStyle.Render("  no matches")
+	}
+
+	m.configureResultsTable(width, height)
+	return m.resultsTable.View()
+}
+
+func (m *model) renderSelectedPreview(width int, height int) string {
+	row, ok := m.currentSelection()
+	if !ok {
+		return ""
+	}
+	title := row.Title
+	if title == "" {
+		title = row.SessionKey
+	}
+	meta := []string{
+		shortCwd(row.Cwd),
+		"created " + friendlyTime(row.CreatedAt),
+		"updated " + friendlyTime(row.UpdatedAt),
+	}
+	if row.Models != "" {
+		meta = append(meta, modelSummary(row.Models))
+	}
+	if row.MessageCount > 0 {
+		meta = append(meta, fmt.Sprintf("%d messages", row.MessageCount))
+	}
+	bodyWidth := max(20, width-4)
+	lines := []string{
+		sectionStyle.Render(fit("preview", bodyWidth)),
+		selectedStyle.Foreground(cyan).Render(fit(title, bodyWidth)),
+		mutedStyle.Render(fit(strings.Join(meta, "  "), bodyWidth)),
+	}
+	if row.Preview != "" {
+		lines = append(lines, mutedStyle.Render(fit("match "+row.Preview, bodyWidth)))
+	}
+	lines = append(lines, lipgloss.NewStyle().Foreground(border).Render(strings.Repeat("─", min(bodyWidth, 32))))
+	lines = append(lines, m.transcriptPreviewLines(row, bodyWidth)...)
+	lines = clipStyledLines(lines, max(1, height-1))
+	return lipgloss.NewStyle().
+		Foreground(fg).
+		Border(lipgloss.NormalBorder(), false, false, false, true).
+		BorderForeground(border).
+		Padding(0, 0, 0, 2).
+		Width(max(1, width-3)).
+		Height(max(1, height)).
+		Render(strings.Join(lines, "\n"))
+}
+
+func clipStyledLines(lines []string, height int) []string {
+	if height <= 0 || len(lines) <= height {
+		return lines
+	}
+	if height == 1 {
+		return []string{mutedStyle.Render("...")}
+	}
+	clipped := append([]string{}, lines[:height-1]...)
+	clipped = append(clipped, mutedStyle.Render("... enter to open full transcript"))
+	return clipped
+}
+
+func (m *model) transcriptPreviewLines(row item, width int) []string {
+	if m.db == nil {
+		fallback := "session " + row.SessionKey
+		if row.Preview != "" {
+			fallback = "match " + row.Preview
+		}
+		return []string{mutedStyle.Render(fit(fallback, width))}
+	}
+	if m.previewKey == row.SessionKey && m.previewWidth == width && m.previewAllRoles == m.allRoles {
+		if m.previewErr != nil {
+			return []string{lipgloss.NewStyle().Foreground(red).Render(fit(m.previewErr.Error(), width))}
+		}
+		return m.previewLines
+	}
+
+	messages, err := loadTranscriptPreviewMessages(m.db, row.SessionKey, m.allRoles, 8)
+	m.previewKey = row.SessionKey
+	m.previewWidth = width
+	m.previewAllRoles = m.allRoles
+	m.previewErr = err
+	if err != nil {
+		m.previewLines = nil
+		return []string{lipgloss.NewStyle().Foreground(red).Render(fit(err.Error(), width))}
+	}
+	m.previewLines = formatTranscriptPreviewLines(messages, width)
+	return m.previewLines
+}
+
+func formatTranscriptPreviewLines(messages []transcriptMessage, width int) []string {
+	if len(messages) == 0 {
+		return []string{mutedStyle.Render("no transcript messages")}
+	}
+	lines := []string{}
+	for _, message := range messages {
+		headerParts := []string{strings.ToUpper(message.Role)}
+		if message.Timestamp != "" {
+			headerParts = append(headerParts, friendlyTime(message.Timestamp))
+		}
+		if message.Model != "" {
+			headerParts = append(headerParts, message.Model)
+		}
+		lines = append(lines, roleStyle(message.Role).Render(fit(strings.Join(headerParts, "  "), width)))
+		textLines := 0
+		for _, raw := range strings.Split(message.Text, "\n") {
+			for _, wrapped := range wrap(raw, max(12, width-2)) {
+				lines = append(lines, baseStyle.Render("  "+fit(wrapped, max(1, width-2))))
+				textLines++
+				if textLines >= 3 {
+					break
+				}
+			}
+			if textLines >= 3 {
+				break
+			}
+		}
+		lines = append(lines, "")
+	}
+	return lines
+}
+
+func (m *model) configureResultsTable(width int, height int) {
+	if width <= 0 {
+		return
+	}
+	if m.resultsTable.Width() == 0 && m.resultsTable.Height() == 0 {
+		m.resultsTable = newResultsTable()
+	}
+	m.resultsTable.SetColumns(resultTableColumns(width))
+	m.selected = clamp(m.selected, 0, max(0, len(m.results)-1))
+	m.resultsTable.SetRows(resultTableRows(m.results, m.selected))
+	m.resultsTable.SetWidth(width)
+	m.resultsTable.SetHeight(max(4, height))
+	m.resultsTable.SetCursor(m.selected)
+	if m.focus == focusResults {
+		m.resultsTable.Focus()
+	} else {
+		m.resultsTable.Blur()
+	}
+}
+
+func resultTableColumns(width int) []table.Column {
+	inner := max(40, width-4)
+	markerWidth := 2
+	ageWidth := 8
+	updatedWidth := 16
+	createdWidth := 16
+	repoWidth := 22
+	harnessWidth := 11
+	messageWidth := 5
+
+	if inner < 96 {
+		createdWidth = 0
+		repoWidth = 18
+	}
+	if inner < 92 {
+		updatedWidth = 12
+		repoWidth = 0
+		messageWidth = 0
+	}
+	if inner < 64 {
+		createdWidth = 0
+		updatedWidth = 0
+		messageWidth = 0
+	}
+
+	columns := []table.Column{
+		{Title: "", Width: markerWidth},
+		{Title: "age", Width: ageWidth},
+		{Title: "updated", Width: updatedWidth},
+		{Title: "created", Width: createdWidth},
+		{Title: "chat", Width: 0},
+		{Title: "repo", Width: repoWidth},
+		{Title: "harness", Width: harnessWidth},
+		{Title: "msgs", Width: messageWidth},
+	}
+	fixed := 0
+	visibleColumns := 0
+	chatIndex := 4
+	for index, column := range columns {
+		if column.Width <= 0 {
+			continue
+		}
+		visibleColumns++
+		if index != chatIndex {
+			fixed += column.Width
+		}
+	}
+	padding := 2 * visibleColumns
+	columns[chatIndex].Width = max(8, inner-fixed-padding)
+	return columns
+}
+
+func resultTableRows(items []item, selected int) []table.Row {
+	rows := make([]table.Row, 0, len(items))
+	for index, row := range items {
+		title := row.Title
+		if title == "" {
+			title = row.SessionKey
+		}
+		marker := ""
+		if index == selected {
+			marker = ">"
+		}
+		rows = append(rows, table.Row{
+			marker,
+			relativeTime(row.UpdatedAt),
+			friendlyTime(row.UpdatedAt),
+			friendlyTime(row.CreatedAt),
+			title,
+			shortCwd(row.Cwd),
+			"[" + providerBadge(row.Provider) + "]",
+			messageCountLabel(row.MessageCount),
+		})
+	}
+	return rows
+}
+
+func messageCountLabel(count int) string {
+	if count <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("%d", count)
+}
+
+func (m *model) currentSelection() (item, bool) {
+	if len(m.results) == 0 {
+		return item{}, false
+	}
+	index := clamp(m.resultsTable.Cursor(), 0, len(m.results)-1)
+	m.selected = index
+	return m.results[index], true
+}
+
+func (m *model) renderFooter(width int) string {
+	m.helpBubble.Width = width
+	return m.helpBubble.View(m.currentHelp())
+}
+
+func (m *model) currentHelp() keySet {
+	if m.filterOpen {
+		return keySet{
+			short: []key.Binding{m.keys.AdvanceFilter, m.keys.Select, m.keys.FilterHarness, m.keys.FilterRepos, m.keys.FilterModels, m.keys.FilterRoles, m.keys.Apply},
+			full: [][]key.Binding{
+				{m.keys.Move, m.keys.AdvanceFilter, m.keys.Select, m.keys.Focus},
+				{m.keys.FilterHarness, m.keys.FilterRepos, m.keys.FilterModels, m.keys.FilterRoles},
+				{m.keys.ClearSection, m.keys.Clear, m.keys.Apply, m.keys.Quit},
+			},
+		}
+	}
+	if m.detail {
+		return keySet{
+			short: []key.Binding{m.keys.Back, m.keys.ExportMarkdown, m.keys.ExportText, m.keys.Move, m.keys.Quit},
+			full: [][]key.Binding{
+				{m.keys.Back, m.keys.Move},
+				{m.keys.ExportMarkdown, m.keys.ExportText, m.keys.Quit},
+			},
+		}
+	}
+	if m.focus == focusSearch {
+		return keySet{
+			short: []key.Binding{m.keys.Filter, m.keys.Focus, m.keys.Search, m.keys.Clear, m.keys.Quit},
+			full: [][]key.Binding{
+				{m.keys.Filter, m.keys.Focus, m.keys.Search, m.keys.Clear},
+				{m.keys.Open, m.keys.Move, m.keys.Quit},
+			},
+		}
+	}
+	return keySet{
+		short: []key.Binding{m.keys.Open, m.keys.ExportMarkdown, m.keys.ExportText, m.keys.Focus, m.keys.Search, m.keys.Quit},
+		full: [][]key.Binding{
+			{m.keys.Open, m.keys.Move, m.keys.Focus, m.keys.Search},
+			{m.keys.ExportMarkdown, m.keys.ExportText, m.keys.Filter, m.keys.Clear, m.keys.Quit},
+		},
+	}
+}
+
+func (m *model) renderBrowseActions(width int, y int) string {
+	buttons := []actionButtonSpec{
+		{Binding: m.keys.Open, Label: "Open", Action: actionOpen},
+		{Binding: m.keys.ExportMarkdown, Label: "Markdown", Action: actionExportMarkdown},
+		{Binding: m.keys.ExportText, Label: "Text", Action: actionExportText},
+	}
+	line, tracked := renderButtonRow(buttons, width, y)
+	m.browseButtons = tracked
+	return line
+}
+
+func (m *model) renderDetailActions(width int, y int) string {
+	buttons := []actionButtonSpec{
+		{Binding: m.keys.Back, Label: "Back", Action: actionBack},
+		{Binding: m.keys.ExportMarkdown, Label: "Markdown", Action: actionExportMarkdown},
+		{Binding: m.keys.ExportText, Label: "Text", Action: actionExportText},
+	}
+	line, tracked := renderButtonRow(buttons, width, y)
+	m.detailButtons = tracked
+	return line
+}
+
+type actionButtonSpec struct {
+	Binding key.Binding
+	Label   string
+	Action  actionKind
+}
+
+func renderButtonRow(specs []actionButtonSpec, width int, y int) (string, []actionButton) {
+	x := 0
+	parts := []string{}
+	buttons := []actionButton{}
+	for _, spec := range specs {
+		rendered := renderButton(spec.Binding, spec.Label)
+		visibleWidth := lipgloss.Width(rendered)
+		if x > 0 {
+			spacer := "  "
+			parts = append(parts, baseStyle.Render(spacer))
+			x += lipgloss.Width(spacer)
+		}
+		if x+visibleWidth > width {
+			break
+		}
+		parts = append(parts, rendered)
+		buttons = append(buttons, actionButton{
+			Label:  spec.Label,
+			Action: spec.Action,
+			X:      x,
+			Y:      y,
+			Width:  visibleWidth,
+		})
+		x += visibleWidth
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Top, parts...), buttons
+}
+
+func renderButton(binding key.Binding, label string) string {
+	helpText := binding.Help()
+	keyText := strings.ToUpper(helpText.Key)
+	if keyText == "" {
+		keyText = " "
+	}
+	text := keyText + " " + label
+	return lipgloss.NewStyle().
+		Foreground(bg).
+		Background(cyan).
+		Bold(true).
+		Padding(0, 1).
+		Render(text)
+}
+
+func renderFilterAction(_ key.Binding, focused bool) string {
+	style := lipgloss.NewStyle().
+		Foreground(bg).
+		Background(cyan).
+		Bold(true).
+		Padding(0, 1)
+	if focused {
+		style = style.Background(yellow)
+	}
+	return style.Render("Ctrl-F Filters")
+}
+
+func filterControl(label string, value string, active bool, color lipgloss.Color) string {
+	marker := mutedStyle.Background(surface).Render("·")
+	if active {
+		marker = lipgloss.NewStyle().Foreground(color).Background(surface).Bold(true).Render("•")
+	}
+	labelStyle := lipgloss.NewStyle().
+		Foreground(color).
+		Background(surface).
+		Bold(true)
+	valueStyle := lipgloss.NewStyle().
+		Foreground(fg).
+		Background(surface)
+	if active {
+		valueStyle = valueStyle.Bold(true)
+	}
+	content := marker + baseStyle.Background(surface).Render(" ") + labelStyle.Render(label+": ") + valueStyle.Render(value)
+	return lipgloss.NewStyle().
+		Foreground(fg).
+		Background(surface).
+		Padding(0, 1).
+		Render(content)
+}
+
+func joinFilterControls(chips []string, width int) string {
+	lines := []string{}
+	current := ""
+	for _, chip := range chips {
+		next := chip
+		if current != "" {
+			next = current + baseStyle.Render("  ") + chip
+		}
+		if current != "" && lipgloss.Width(next) > width {
+			lines = append(lines, current)
+			current = chip
+			continue
+		}
+		current = next
+	}
+	if current != "" {
+		lines = append(lines, current)
+	}
+	return strings.Join(lines, "\n")
+}
+
+func (m *model) filterView() string {
+	width := max(72, m.width)
+	title := sectionStyle.Render("Filters")
+	step := selectedStyle.Foreground(cyan).Render(fmt.Sprintf("Step %d of %d  %s", int(m.filterSection)+1, int(filterSectionCount), filterSectionTitle(m.filterSection)))
+	summary := mutedStyle.Render(fit(m.filterSummary(), width))
+	steps := m.renderFilterSteps(width)
+	instructions := mutedStyle.Render(fit("Enter selects and advances. Space selects without moving. Esc applies filters.", width))
+	rule := lipgloss.NewStyle().Foreground(border).Render(strings.Repeat("─", max(0, width-2)))
+	top := []string{title, step, summary, steps, instructions, rule}
+	bodyHeight := max(1, m.height-lipgloss.Height(strings.Join(top, "\n"))-2)
+	lines := append(top, m.renderFilterOptions(width, bodyHeight))
+	lines = append(lines, m.renderFooter(width))
+	return baseStyle.Width(width).Height(m.height).Render(strings.Join(lines, "\n"))
+}
+
+func (m *model) renderFilterSteps(_ int) string {
+	labels := []string{
+		"1 Harness " + selectionCount(len(m.providers)),
+		"2 Repos " + selectionCount(len(m.repoFilters)),
+		"3 Models " + selectionCount(len(m.modelFilters)),
+		"4 Roles",
+	}
+	parts := make([]string, 0, len(labels))
+	for index, label := range labels {
+		active := filterSection(index) == m.filterSection
+		parts = append(parts, filterStep(label, active))
+		if index < len(labels)-1 {
+			parts = append(parts, mutedStyle.Render(" > "))
+		}
+	}
+	return lipgloss.JoinHorizontal(lipgloss.Top, parts...)
+}
+
+func (m *model) renderFilterOptions(width int, height int) string {
+	m.configureFilterList(width, height)
+	return m.filterList.View()
+}
+
+func (m *model) configureFilterList(width int, height int) {
+	if width <= 0 {
+		return
+	}
+	if m.filterList.Width() == 0 && m.filterList.Height() == 0 {
+		m.filterList = newFilterList(width, height)
+	}
+	m.filterList.Title = filterSectionTitle(m.filterSection)
+	m.filterList.SetSize(width, max(3, height))
+	_ = m.filterList.SetItems(m.filterListItems())
+}
+
+func (m *model) filterListItems() []list.Item {
+	options := m.currentFilterOptions()
+	items := make([]list.Item, 0, len(options))
+	for _, option := range options {
+		description := option.Value
+		if option.Count > 0 {
+			description = fmt.Sprintf("%d chats  %s", option.Count, option.Value)
+		}
+		if m.filterSection == sectionRoles {
+			description = "controls whether transcripts include system, developer, and tool messages"
+		}
+		items = append(items, filterListItem{
+			option:      option,
+			selected:    m.filterOptionSelected(option),
+			section:     m.filterSection,
+			description: description,
+		})
+	}
+	return items
+}
+
+func filterStep(label string, active bool) string {
+	style := lipgloss.NewStyle().
+		Foreground(muted).
+		Background(bg).
+		Padding(0, 1).
+		Bold(true)
+	if active {
+		style = style.Foreground(bg).Background(cyan)
+	}
+	return style.Render(label)
+}
+
+func filterSectionTitle(section filterSection) string {
+	switch section {
+	case sectionHarness:
+		return "Choose harnesses"
+	case sectionRepos:
+		return "Choose repos"
+	case sectionModels:
+		return "Choose models"
+	case sectionRoles:
+		return "Choose roles"
+	default:
+		return "Choose filters"
+	}
+}
+
+func (m *model) detailView() string {
+	width := max(72, m.width)
+	row := m.currentDetailItem()
+	badge := "[" + providerLabel(row.Provider) + "]"
+	titleWidth := max(10, width-lipgloss.Width(badge)-1)
+	header := providerStyle(row.Provider, false).Render(badge) + " " + sectionStyle.Render(fit(row.Title, titleWidth))
+	meta := mutedStyle.Render(fit(friendlyTime(row.Timestamp)+"  "+shortCwd(row.Cwd)+"  "+modelSummary(row.Models), width))
+	actions := m.renderDetailActions(width, 2)
+	help := m.renderFooter(width)
+	status := m.renderDetailStatus(width)
+	rule := lipgloss.NewStyle().Foreground(border).Render(strings.Repeat("─", max(0, width-2)))
+	top := []string{header, meta, actions, help}
+	if status != "" {
+		top = append(top, status)
+	}
+	top = append(top, rule)
+
+	m.transcriptView.Width = max(20, width-2)
+	m.transcriptView.Height = max(1, m.height-len(top)-1)
+	return baseStyle.Width(width).Height(m.height).Render(strings.Join(top, "\n") + "\n" + m.transcriptView.View())
+}
+
+func (m *model) renderDetailStatus(width int) string {
+	if m.err != nil {
+		return lipgloss.NewStyle().Foreground(red).Background(bg).Render(fit(m.err.Error(), width))
+	}
+	if m.notice != "" {
+		return mutedStyle.Render(fit(m.notice, width))
+	}
+	return ""
+}
+
+func (m *model) move(delta int) {
+	if len(m.results) == 0 {
+		m.selected = 0
+		return
+	}
+	if delta < 0 {
+		m.resultsTable.MoveUp(-delta)
+	} else {
+		m.resultsTable.MoveDown(delta)
+	}
+	m.selected = clamp(m.resultsTable.Cursor(), 0, len(m.results)-1)
+}
+
+func (m *model) openDetail() {
+	if len(m.results) == 0 {
+		return
+	}
+	row, ok := m.currentSelection()
+	if !ok {
+		return
+	}
+	content, err := loadTranscript(m.db, row.SessionKey, m.allRoles, max(40, m.width-4))
+	if err != nil {
+		m.err = err
+		return
+	}
+	m.detailItem = row
+	m.notice = ""
+	m.transcriptView.SetContent(content)
+	m.transcriptView.GotoTop()
+	m.detail = true
+}
+
+func (m *model) exportSelected(format string) {
+	m.err = nil
+	row, ok := m.exportTarget()
+	if !ok {
+		m.notice = "no chat selected"
+		return
+	}
+	messages, err := loadTranscriptMessages(m.db, row.SessionKey, m.allRoles)
+	if err != nil {
+		m.err = err
+		return
+	}
+	if len(messages) == 0 {
+		m.notice = "selected chat has no exportable messages"
+		return
+	}
+	content := formatTranscriptExport(row, messages, format)
+	path, err := exportFilePath(row, format)
+	if err != nil {
+		m.err = err
+		return
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+		m.err = err
+		return
+	}
+	if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
+		m.err = err
+		return
+	}
+	m.notice = "exported " + path
+}
+
+func (m *model) exportTarget() (item, bool) {
+	if m.detail && m.detailItem.SessionKey != "" {
+		return m.detailItem, true
+	}
+	if len(m.results) == 0 {
+		return item{}, false
+	}
+	return m.currentSelection()
+}
+
+func (m *model) currentDetailItem() item {
+	if m.detailItem.SessionKey != "" {
+		return m.detailItem
+	}
+	if len(m.results) == 0 {
+		return item{}
+	}
+	row, _ := m.currentSelection()
+	return row
+}
+
+func (m *model) openFilters() {
+	m.filterOpen = true
+	m.setFocus(focusFilters)
+	m.configureFilterList(max(72, m.width), max(8, m.height-8))
+}
+
+func (m *model) closeFilters() {
+	m.filterOpen = false
+	m.setFocus(focusFilters)
+	m.resetPosition()
+	m.reload()
+}
+
+func (m *model) handleFilterKey(msg tea.KeyMsg) tea.Cmd {
+	m.configureFilterList(max(72, m.width), max(8, m.height-8))
+	switch msg.String() {
+	case "ctrl+c":
+		return tea.Quit
+	case "esc", "left":
+		m.closeFilters()
+	case "tab", "right":
+		m.advanceFilterSection()
+	case "shift+tab":
+		m.previousFilterSection()
+	case "up", "k", "down", "j", "pgup", "pgdown":
+		var cmd tea.Cmd
+		m.filterList, cmd = m.filterList.Update(msg)
+		return cmd
+	case " ":
+		m.toggleCurrentFilter()
+	case "enter":
+		m.toggleCurrentFilter()
+		m.advanceFilterSection()
+	case "c":
+		m.clearCurrentFilterSection()
+	case "ctrl+u":
+		m.clearFilters()
+		m.configureFilterList(max(72, m.width), max(8, m.height-8))
+	case "1", "h":
+		m.setFilterSection(sectionHarness)
+	case "2", "r":
+		m.setFilterSection(sectionRepos)
+	case "3", "m":
+		m.setFilterSection(sectionModels)
+	case "4", "o":
+		m.setFilterSection(sectionRoles)
+	default:
+		return nil
+	}
+	return nil
+}
+
+func (m *model) handleFilterClick(msg tea.MouseMsg) {
+	width := max(72, m.width)
+	sectionWidth := max(18, width/int(filterSectionCount))
+	if msg.Y == 3 {
+		clickedSection := clamp(msg.X/sectionWidth, 0, int(filterSectionCount)-1)
+		m.setFilterSection(filterSection(clickedSection))
+		return
+	}
+	if msg.Y < 6 {
+		return
+	}
+	listTop := 8
+	visibleIndex := max(0, msg.Y-listTop) / 2
+	index := m.filterList.Paginator.Page*m.filterList.Paginator.PerPage + visibleIndex
+	options := m.currentFilterOptions()
+	if index < len(options) {
+		m.toggleFilterOption(options[index])
+		m.configureFilterList(width, max(8, m.height-8))
+	}
+}
+
+func (m *model) setFilterSection(section filterSection) {
+	m.filterSection = section
+	m.filterList.GoToStart()
+	m.configureFilterList(max(72, m.width), max(8, m.height-8))
+}
+
+func (m *model) advanceFilterSection() {
+	m.setFilterSection((m.filterSection + 1) % filterSectionCount)
+}
+
+func (m *model) previousFilterSection() {
+	m.setFilterSection((m.filterSection + filterSectionCount - 1) % filterSectionCount)
+}
+
+func (m *model) toggleCurrentFilter() {
+	selected, ok := m.filterList.SelectedItem().(filterListItem)
+	if !ok {
+		return
+	}
+	m.toggleFilterOption(selected.option)
+	m.configureFilterList(max(72, m.width), max(8, m.height-8))
+}
+
+func (m *model) toggleFilterOption(selected filterOption) {
+	switch m.filterSection {
+	case sectionHarness:
+		toggleSetValue(m.providers, selected.Value)
+	case sectionRepos:
+		toggleSetValue(m.repoFilters, selected.Value)
+	case sectionModels:
+		toggleSetValue(m.modelFilters, selected.Value)
+	case sectionRoles:
+		m.allRoles = selected.Value == "all"
+	}
+	m.notice = "filters updated"
+}
+
+func (m *model) clearCurrentFilterSection() {
+	switch m.filterSection {
+	case sectionHarness:
+		clearSet(m.providers)
+	case sectionRepos:
+		clearSet(m.repoFilters)
+	case sectionModels:
+		clearSet(m.modelFilters)
+	case sectionRoles:
+		m.allRoles = true
+	}
+	m.notice = "filter section cleared"
+	m.configureFilterList(max(72, m.width), max(8, m.height-8))
+}
+
+func (m *model) clearFilters() {
+	clearSet(m.providers)
+	clearSet(m.repoFilters)
+	clearSet(m.modelFilters)
+	m.allRoles = true
+}
+
+func (m *model) currentFilterOptions() []filterOption {
+	switch m.filterSection {
+	case sectionHarness:
+		return m.providerOptions
+	case sectionRepos:
+		return m.repoOptions
+	case sectionModels:
+		return m.modelOptions
+	case sectionRoles:
+		return []filterOption{
+			{Value: "all", Label: "all roles"},
+			{Value: "conversation", Label: "user + assistant"},
+		}
+	default:
+		return nil
+	}
+}
+
+func (m *model) filterOptionSelected(option filterOption) bool {
+	switch m.filterSection {
+	case sectionHarness:
+		return m.providers[option.Value]
+	case sectionRepos:
+		return m.repoFilters[option.Value]
+	case sectionModels:
+		return m.modelFilters[option.Value]
+	case sectionRoles:
+		if option.Value == "all" {
+			return m.allRoles
+		}
+		return !m.allRoles
+	default:
+		return false
+	}
+}
+
+func (m *model) hasActiveFilters() bool {
+	return len(m.providers) > 0 || len(m.repoFilters) > 0 || len(m.modelFilters) > 0 || !m.allRoles
+}
+
+func (m *model) providerSummary() string {
+	return summarizeSet(m.providers, m.providerOptions, "all harnesses", "harnesses")
+}
+
+func (m *model) compactProviderSummary() string {
+	return compactSetSummary(m.providers, m.providerOptions, "all")
+}
+
+func (m *model) repoSummary() string {
+	return summarizeSet(m.repoFilters, m.repoOptions, "any repo", "repos")
+}
+
+func (m *model) compactRepoSummary() string {
+	return compactSetSummary(m.repoFilters, m.repoOptions, "any")
+}
+
+func (m *model) modelSummary() string {
+	return summarizeSet(m.modelFilters, m.modelOptions, "any model", "models")
+}
+
+func (m *model) compactModelSummary() string {
+	return compactSetSummary(m.modelFilters, m.modelOptions, "any")
+}
+
+func (m *model) filterSummary() string {
+	roles := "all roles"
+	if !m.allRoles {
+		roles = "user+assistant"
+	}
+	return strings.Join([]string{
+		"harness " + m.providerSummary(),
+		"repo " + m.repoSummary(),
+		"model " + m.modelSummary(),
+		"roles " + roles,
+	}, "  ")
+}
+
+func summarizeSet(selected map[string]bool, options []filterOption, empty string, plural string) string {
+	if len(selected) == 0 {
+		return empty
+	}
+	labels := selectedLabels(selected, options)
+	if len(labels) == 1 {
+		return labels[0]
+	}
+	if len(labels) == 2 {
+		return labels[0] + " + " + labels[1]
+	}
+	return fmt.Sprintf("%d %s", len(labels), plural)
+}
+
+func compactSetSummary(selected map[string]bool, options []filterOption, empty string) string {
+	if len(selected) == 0 {
+		return empty
+	}
+	labels := selectedLabels(selected, options)
+	if len(labels) == 1 {
+		return fit(labels[0], 24)
+	}
+	return fmt.Sprintf("%d selected", len(labels))
+}
+
+func selectedLabels(selected map[string]bool, options []filterOption) []string {
+	labels := []string{}
+	for _, option := range options {
+		if selected[option.Value] {
+			labels = append(labels, option.Label)
+		}
+	}
+	if len(labels) > 0 {
+		return labels
+	}
+	for value := range selected {
+		labels = append(labels, value)
+	}
+	sort.Strings(labels)
+	return labels
+}
+
+func selectionCount(count int) string {
+	if count == 0 {
+		return "(all)"
+	}
+	return fmt.Sprintf("(%d)", count)
+}
+
+func selectedSetValues(set map[string]bool) []string {
+	values := make([]string, 0, len(set))
+	for value := range set {
+		values = append(values, value)
+	}
+	sort.Strings(values)
+	return values
+}
+
+func toggleSetValue(set map[string]bool, value string) {
+	if set[value] {
+		delete(set, value)
+		return
+	}
+	set[value] = true
+}
+
+func clearSet(set map[string]bool) {
+	for value := range set {
+		delete(set, value)
+	}
+}
+
+func (m *model) reload() {
+	m.err = nil
+	var rows []item
+	var err error
+	query := strings.TrimSpace(m.search.Value())
+	providers := selectedSetValues(m.providers)
+	models := selectedSetValues(m.modelFilters)
+	repos := selectedSetValues(m.repoFilters)
+	if query == "" {
+		rows, err = listSessions(m.db, providers, models, repos)
+	} else {
+		rows, err = searchMessages(m.db, query, providers, models, repos, m.allRoles)
+	}
+	if err != nil {
+		m.err = err
+		m.results = nil
+		return
+	}
+	m.results = rows
+	if m.selected >= len(m.results) {
+		m.selected = max(0, len(m.results)-1)
+	}
+	m.configureResultsTable(max(72, m.width), max(4, m.height/2))
+}
+
+func (m *model) resetPosition() {
+	m.selected = 0
+	m.resultsTable.SetCursor(0)
+	m.detail = false
+}
+
+func (m *model) detailHeight() int {
+	return max(1, m.height-5)
+}
+
+func loadProviderOptions(db *sql.DB) ([]filterOption, error) {
+	rows, err := db.Query(`
+		SELECT s.provider, COUNT(*) AS sessions
+		FROM sessions s
+		WHERE ` + rootSessionFilter("s") + `
+		  AND ` + displayableSessionFilter("s") + `
+		GROUP BY s.provider
+		ORDER BY CASE s.provider WHEN 'codex' THEN 0 WHEN 'claude' THEN 1 WHEN 'pi' THEN 2 ELSE 3 END, s.provider
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	options := []filterOption{}
+	for rows.Next() {
+		var provider string
+		var count int
+		if err := rows.Scan(&provider, &count); err != nil {
+			return nil, err
+		}
+		options = append(options, filterOption{
+			Value: provider,
+			Label: providerLabel(provider),
+			Count: count,
+		})
+	}
+	return options, rows.Err()
+}
+
+func loadRepoOptions(db *sql.DB) ([]filterOption, error) {
+	rows, err := db.Query(`
+		SELECT COALESCE(s.cwd, ''), COUNT(*) AS sessions
+		FROM sessions s
+		WHERE COALESCE(s.cwd, '') != ''
+		  AND ` + rootSessionFilter("s") + `
+		  AND ` + displayableSessionFilter("s") + `
+		GROUP BY s.cwd
+		ORDER BY sessions DESC, MAX(COALESCE(s.updated_at, s.started_at, s.imported_at)) DESC, s.cwd ASC
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	options := []filterOption{}
+	for rows.Next() {
+		var cwd string
+		var count int
+		if err := rows.Scan(&cwd, &count); err != nil {
+			return nil, err
+		}
+		options = append(options, filterOption{
+			Value: cwd,
+			Label: shortCwd(cwd),
+			Count: count,
+		})
+	}
+	return options, rows.Err()
+}
+
+func loadModelOptions(db *sql.DB) ([]filterOption, error) {
+	rows, err := db.Query(`
+		SELECT sm.model, COUNT(DISTINCT sm.session_key) AS sessions
+		FROM session_models sm
+		JOIN sessions s ON s.session_key = sm.session_key
+		WHERE sm.model != ''
+		  AND ` + rootSessionFilter("s") + `
+		  AND ` + displayableSessionFilter("s") + `
+		GROUP BY sm.model
+		ORDER BY sessions DESC, sm.model ASC
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	options := []filterOption{}
+	for rows.Next() {
+		var name string
+		var count int
+		if err := rows.Scan(&name, &count); err != nil {
+			return nil, err
+		}
+		options = append(options, filterOption{Value: name, Label: name, Count: count})
+	}
+	return options, rows.Err()
+}
+
+func listSessions(db *sql.DB, providers []string, models []string, repos []string) ([]item, error) {
+	filters, args := sessionFilters("s", providers, models, repos)
+	filters = append(filters, rootSessionFilter("s"))
+	filters = append(filters, displayableSessionFilter("s"))
+	where := ""
+	if len(filters) > 0 {
+		where = "WHERE " + strings.Join(filters, " AND ")
+	}
+	rows, err := db.Query(`
+		SELECT s.session_key, s.provider, `+displayTitleExpr("s")+`,
+		       COALESCE(s.started_at, ''),
+		       COALESCE(s.updated_at, s.started_at, ''),
+		       COALESCE(s.cwd, ''), COALESCE(s.message_count, 0),
+		       COALESCE((SELECT GROUP_CONCAT(model) FROM (
+		           SELECT DISTINCT sm.model FROM session_models sm
+		           WHERE sm.session_key = s.session_key
+		           ORDER BY sm.model
+		       )), '')
+		FROM sessions s
+		`+where+`
+		ORDER BY COALESCE(s.updated_at, s.started_at, s.imported_at) DESC
+	`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	items := []item{}
+	for rows.Next() {
+		var row item
+		if err := rows.Scan(&row.SessionKey, &row.Provider, &row.Title, &row.CreatedAt, &row.UpdatedAt, &row.Cwd, &row.MessageCount, &row.Models); err != nil {
+			return nil, err
+		}
+		row.Timestamp = row.UpdatedAt
+		row.Title = oneLine(row.Title)
+		items = append(items, row)
+	}
+	return items, rows.Err()
+}
+
+func searchMessages(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
+	rows, err := searchMessagesFTS(db, query, providers, models, repos, allRoles)
+	if err == nil {
+		return rows, nil
+	}
+	return searchMessagesLike(db, query, providers, models, repos, allRoles)
+}
+
+func searchMessagesFTS(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
+	args := []any{toFTSQuery(query)}
+	filters := messageFilters("m", providers, models, repos, allRoles, &args)
+	filters = append(filters, rootSessionFilter("s"))
+	filters = append(filters, displayableSessionFilter("s"))
+	where := "message_fts MATCH ?"
+	if len(filters) > 0 {
+		where += " AND " + strings.Join(filters, " AND ")
+	}
+	rows, err := db.Query(`
+		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
+		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
+		       COALESCE(s.started_at, ''),
+		       COALESCE(s.updated_at, s.started_at, ''),
+		       COALESCE(s.cwd, ''), COALESCE(s.message_count, 0),
+		       COALESCE((SELECT GROUP_CONCAT(model) FROM (
+		           SELECT DISTINCT sm.model FROM session_models sm
+		           WHERE sm.session_key = m.session_key
+		           ORDER BY sm.model
+		       )), ''),
+		       COALESCE(snippet(message_fts, 0, '[', ']', '...', 18), m.text),
+		       m.ordinal
+		FROM message_fts
+		JOIN messages m ON m.message_key = message_fts.message_key
+		JOIN sessions s ON s.session_key = m.session_key
+		WHERE `+where+`
+		ORDER BY bm25(message_fts), COALESCE(m.timestamp, s.updated_at) DESC
+	`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items, err := scanItems(rows, true)
+	if err != nil {
+		return nil, err
+	}
+	return dedupeItems(items), nil
+}
+
+func searchMessagesLike(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
+	args := []any{"%" + query + "%"}
+	filters := []string{"m.text LIKE ?"}
+	filters = append(filters, messageFilters("m", providers, models, repos, allRoles, &args)...)
+	filters = append(filters, rootSessionFilter("s"))
+	filters = append(filters, displayableSessionFilter("s"))
+
+	rows, err := db.Query(`
+		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
+		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
+		       COALESCE(s.started_at, ''),
+		       COALESCE(s.updated_at, s.started_at, ''),
+		       COALESCE(s.cwd, ''), COALESCE(s.message_count, 0),
+		       COALESCE((SELECT GROUP_CONCAT(model) FROM (
+		           SELECT DISTINCT sm.model FROM session_models sm
+		           WHERE sm.session_key = m.session_key
+		           ORDER BY sm.model
+		       )), ''),
+		       m.text,
+		       m.ordinal
+		FROM messages m
+		JOIN sessions s ON s.session_key = m.session_key
+		WHERE `+strings.Join(filters, " AND ")+`
+		ORDER BY COALESCE(m.timestamp, s.updated_at) DESC
+	`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items, err := scanItems(rows, true)
+	if err != nil {
+		return nil, err
+	}
+	return dedupeItems(items), nil
+}
+
+func scanItems(rows *sql.Rows, isMatch bool) ([]item, error) {
+	items := []item{}
+	for rows.Next() {
+		var row item
+		if err := rows.Scan(&row.SessionKey, &row.Provider, &row.Title, &row.Timestamp, &row.CreatedAt, &row.UpdatedAt, &row.Cwd, &row.MessageCount, &row.Models, &row.Preview, &row.Ordinal); err != nil {
+			return nil, err
+		}
+		if row.UpdatedAt == "" {
+			row.UpdatedAt = row.Timestamp
+		}
+		row.IsMatch = isMatch
+		row.Title = oneLine(row.Title)
+		row.Preview = oneLine(row.Preview)
+		items = append(items, row)
+	}
+	return items, rows.Err()
+}
+
+func dedupeItems(items []item) []item {
+	seen := map[string]bool{}
+	deduped := []item{}
+	for _, row := range items {
+		if seen[row.SessionKey] {
+			continue
+		}
+		seen[row.SessionKey] = true
+		deduped = append(deduped, row)
+	}
+	return deduped
+}
+
+func loadTranscript(db *sql.DB, sessionKey string, allRoles bool, width int) (string, error) {
+	messages, err := loadTranscriptMessages(db, sessionKey, allRoles)
+	if err != nil {
+		return "", err
+	}
+	lines := []string{}
+	for _, message := range messages {
+		header := strings.ToUpper(message.Role) + "  " + message.Timestamp
+		if message.Model != "" {
+			header += "  " + message.Model
+		}
+		lines = append(lines, roleStyle(message.Role).Render(header))
+		for _, raw := range strings.Split(message.Text, "\n") {
+			for _, wrapped := range wrap(raw, max(24, width-4)) {
+				lines = append(lines, baseStyle.Render("  "+wrapped))
+			}
+		}
+		lines = append(lines, "")
+	}
+	if len(lines) == 0 {
+		return mutedStyle.Render("No transcript messages matched the current role filter."), nil
+	}
+	return strings.Join(lines, "\n"), nil
+}
+
+func loadTranscriptMessages(db *sql.DB, sessionKey string, allRoles bool) ([]transcriptMessage, error) {
+	return loadTranscriptMessagesWithLimit(db, sessionKey, allRoles, 0)
+}
+
+func loadTranscriptPreviewMessages(db *sql.DB, sessionKey string, allRoles bool, limit int) ([]transcriptMessage, error) {
+	args := []any{sessionKey, "developer", "system"}
+	filters := []string{
+		"session_key = ?",
+		"role NOT IN (?, ?)",
+		"NOT " + hiddenTitleExpr("text"),
+	}
+	if !allRoles {
+		filters = append(filters, "role IN (?, ?)")
+		args = append(args, "user", "assistant")
+	}
+	if limit > 0 {
+		args = append(args, limit)
+	}
+	limitSQL := ""
+	if limit > 0 {
+		limitSQL = "LIMIT ?"
+	}
+	rows, err := db.Query(`
+		SELECT role, COALESCE(timestamp, ''), COALESCE(model, ''), text
+		FROM messages
+		WHERE `+strings.Join(filters, " AND ")+`
+		ORDER BY
+			CASE WHEN timestamp IS NULL OR timestamp = '' THEN 1 ELSE 0 END,
+			timestamp ASC,
+			ordinal ASC
+		`+limitSQL+`
+	`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	messages := []transcriptMessage{}
+	for rows.Next() {
+		var message transcriptMessage
+		if err := rows.Scan(&message.Role, &message.Timestamp, &message.Model, &message.Text); err != nil {
+			return nil, err
+		}
+		messages = append(messages, message)
+	}
+	return messages, rows.Err()
+}
+
+func loadTranscriptMessagesWithLimit(db *sql.DB, sessionKey string, allRoles bool, limit int) ([]transcriptMessage, error) {
+	args := []any{sessionKey}
+	roleSQL := ""
+	if !allRoles {
+		roleSQL = "AND role IN (?, ?)"
+		args = append(args, "user", "assistant")
+	}
+	limitSQL := ""
+	if limit > 0 {
+		limitSQL = "LIMIT ?"
+		args = append(args, limit)
+	}
+	rows, err := db.Query(`
+		SELECT role, COALESCE(timestamp, ''), COALESCE(model, ''), text
+		FROM messages
+		WHERE session_key = ? `+roleSQL+`
+		ORDER BY
+			CASE WHEN timestamp IS NULL OR timestamp = '' THEN 1 ELSE 0 END,
+			timestamp ASC,
+			ordinal ASC
+		`+limitSQL+`
+	`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	messages := []transcriptMessage{}
+	for rows.Next() {
+		var message transcriptMessage
+		if err := rows.Scan(&message.Role, &message.Timestamp, &message.Model, &message.Text); err != nil {
+			return nil, err
+		}
+		messages = append(messages, message)
+	}
+	return messages, rows.Err()
+}
+
+func formatTranscriptExport(row item, messages []transcriptMessage, format string) string {
+	if format == "md" {
+		return formatTranscriptMarkdown(row, messages)
+	}
+	return formatTranscriptText(row, messages)
+}
+
+func formatTranscriptMarkdown(row item, messages []transcriptMessage) string {
+	var b strings.Builder
+	title := row.Title
+	if title == "" {
+		title = row.SessionKey
+	}
+	b.WriteString("# " + title + "\n\n")
+	writeMarkdownMeta(&b, "Harness", providerLabel(row.Provider))
+	writeMarkdownMeta(&b, "Session", row.SessionKey)
+	writeMarkdownMeta(&b, "Date", friendlyTime(row.Timestamp))
+	writeMarkdownMeta(&b, "Repo", row.Cwd)
+	writeMarkdownMeta(&b, "Models", row.Models)
+	b.WriteString("\n## Transcript\n\n")
+	for _, message := range messages {
+		heading := strings.ToUpper(message.Role)
+		b.WriteString("### " + heading + "\n\n")
+		meta := strings.TrimSpace(strings.Join(nonEmpty([]string{message.Timestamp, message.Model}), "  "))
+		if meta != "" {
+			b.WriteString("_" + escapeMarkdown(meta) + "_\n\n")
+		}
+		b.WriteString(strings.TrimRight(message.Text, "\n") + "\n\n")
+	}
+	return b.String()
+}
+
+func writeMarkdownMeta(b *strings.Builder, label string, value string) {
+	if strings.TrimSpace(value) == "" {
+		return
+	}
+	b.WriteString("- **" + label + ":** " + escapeMarkdown(value) + "\n")
+}
+
+func formatTranscriptText(row item, messages []transcriptMessage) string {
+	var b strings.Builder
+	title := row.Title
+	if title == "" {
+		title = row.SessionKey
+	}
+	b.WriteString(title + "\n")
+	b.WriteString(strings.Repeat("=", len([]rune(title))) + "\n\n")
+	writeTextMeta(&b, "Harness", providerLabel(row.Provider))
+	writeTextMeta(&b, "Session", row.SessionKey)
+	writeTextMeta(&b, "Date", friendlyTime(row.Timestamp))
+	writeTextMeta(&b, "Repo", row.Cwd)
+	writeTextMeta(&b, "Models", row.Models)
+	b.WriteString("\nTranscript\n\n")
+	for _, message := range messages {
+		headerParts := nonEmpty([]string{strings.ToUpper(message.Role), message.Timestamp, message.Model})
+		b.WriteString(strings.Join(headerParts, "  ") + "\n")
+		b.WriteString(strings.TrimRight(message.Text, "\n") + "\n\n")
+	}
+	return b.String()
+}
+
+func writeTextMeta(b *strings.Builder, label string, value string) {
+	if strings.TrimSpace(value) == "" {
+		return
+	}
+	b.WriteString(label + ": " + value + "\n")
+}
+
+func exportFilePath(row item, format string) (string, error) {
+	ext := "txt"
+	if format == "md" {
+		ext = "md"
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	dir := filepath.Join(home, "Downloads", "gora-exports")
+	baseParts := []string{
+		safeFilenamePart(row.Provider),
+		safeFilenamePart(shortSessionKey(row.SessionKey)),
+		safeFilenamePart(row.Title),
+	}
+	base := strings.Join(nonEmpty(baseParts), "-")
+	if base == "" {
+		base = "chat"
+	}
+	return uniqueFilePath(filepath.Join(dir, fitFilename(base, 120)+"."+ext)), nil
+}
+
+func uniqueFilePath(path string) string {
+	if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
+		return path
+	}
+	ext := filepath.Ext(path)
+	stem := strings.TrimSuffix(path, ext)
+	for index := 2; ; index++ {
+		candidate := fmt.Sprintf("%s-%d%s", stem, index, ext)
+		if _, err := os.Stat(candidate); errors.Is(err, os.ErrNotExist) {
+			return candidate
+		}
+	}
+}
+
+func shortSessionKey(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	if parts := strings.Split(value, ":"); len(parts) > 1 {
+		value = parts[len(parts)-1]
+	}
+	if len(value) > 12 {
+		return value[:12]
+	}
+	return value
+}
+
+func safeFilenamePart(value string) string {
+	value = strings.ToLower(oneLine(value))
+	var b strings.Builder
+	lastDash := false
+	for _, r := range value {
+		keep := (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9')
+		if keep {
+			b.WriteRune(r)
+			lastDash = false
+			continue
+		}
+		if !lastDash {
+			b.WriteRune('-')
+			lastDash = true
+		}
+	}
+	return strings.Trim(b.String(), "-")
+}
+
+func fitFilename(value string, width int) string {
+	if len(value) <= width {
+		return value
+	}
+	return strings.Trim(value[:width], "-")
+}
+
+func escapeMarkdown(value string) string {
+	replacer := strings.NewReplacer(`\`, `\\`, `*`, `\*`, `_`, `\_`, "`", "\\`")
+	return replacer.Replace(value)
+}
+
+func nonEmpty(values []string) []string {
+	out := []string{}
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			out = append(out, value)
+		}
+	}
+	return out
+}
+
+func sessionFilters(alias string, providers []string, models []string, repos []string) ([]string, []any) {
+	args := []any{}
+	filters := []string{}
+	appendInFilter(&filters, &args, alias+".provider", providers)
+	appendInFilter(&filters, &args, alias+".cwd", repos)
+	if len(models) > 0 {
+		filters = append(filters, "EXISTS (SELECT 1 FROM session_models sm_filter WHERE sm_filter.session_key = "+alias+".session_key AND sm_filter.model IN ("+placeholders(len(models))+"))")
+		for _, modelName := range models {
+			args = append(args, modelName)
+		}
+	}
+	return filters, args
+}
+
+func messageFilters(alias string, providers []string, models []string, repos []string, allRoles bool, args *[]any) []string {
+	filters := []string{}
+	appendInFilter(&filters, args, alias+".provider", providers)
+	if !allRoles {
+		filters = append(filters, alias+".role IN (?, ?)")
+		*args = append(*args, "user", "assistant")
+	}
+	appendInFilter(&filters, args, "s.cwd", repos)
+	if len(models) > 0 {
+		filters = append(filters, "EXISTS (SELECT 1 FROM session_models sm_filter WHERE sm_filter.session_key = "+alias+".session_key AND sm_filter.model IN ("+placeholders(len(models))+"))")
+		for _, modelName := range models {
+			*args = append(*args, modelName)
+		}
+	}
+	return filters
+}
+
+func appendInFilter(filters *[]string, args *[]any, expr string, values []string) {
+	if len(values) == 0 {
+		return
+	}
+	if len(values) == 1 {
+		*filters = append(*filters, expr+" = ?")
+		*args = append(*args, values[0])
+		return
+	}
+	*filters = append(*filters, expr+" IN ("+placeholders(len(values))+")")
+	for _, value := range values {
+		*args = append(*args, value)
+	}
+}
+
+func placeholders(count int) string {
+	if count <= 0 {
+		return ""
+	}
+	return strings.TrimRight(strings.Repeat("?,", count), ",")
+}
+
+func displayTitleExpr(alias string) string {
+	title := alias + ".title"
+	fallback := firstDisplayableMessageExpr(alias)
+	return `COALESCE(
+		NULLIF(TRIM(CASE WHEN ` + hiddenTitleExpr(title) + ` THEN ` + fallback + ` ELSE ` + title + ` END), ''),
+		NULLIF(TRIM(` + fallback + `), ''),
+		` + alias + `.session_key
+	)`
+}
+
+func firstDisplayableMessageExpr(alias string) string {
+	return `(
+		SELECT title_message.text FROM messages title_message
+		WHERE title_message.session_key = ` + alias + `.session_key
+		  AND title_message.role IN ('user', 'assistant')
+		  AND NOT ` + hiddenTitleExpr("title_message.text") + `
+		ORDER BY CASE title_message.role WHEN 'user' THEN 0 ELSE 1 END, title_message.ordinal ASC
+		LIMIT 1
+	)`
+}
+
+func displayableSessionFilter(alias string) string {
+	return `EXISTS (
+		SELECT 1 FROM messages title_message
+		WHERE title_message.session_key = ` + alias + `.session_key
+		  AND title_message.role IN ('user', 'assistant')
+		  AND NOT ` + hiddenTitleExpr("title_message.text") + `
+	)`
+}
+
+func rootSessionFilter(alias string) string {
+	return "(" + alias + ".parent_session_key IS NULL OR " + alias + ".parent_session_key = '')"
+}
+
+func hiddenTitleExpr(expr string) string {
+	return `(
+		` + expr + ` IS NULL
+		OR TRIM(` + expr + `) = ''
+		OR LTRIM(` + expr + `) LIKE '# AGENTS.md instructions%'
+		OR LTRIM(` + expr + `) LIKE 'AGENTS.md instructions%'
+		OR LTRIM(` + expr + `) LIKE '<turn_aborted>%'
+		OR LTRIM(` + expr + `) LIKE '<user_action>%'
+		OR LTRIM(` + expr + `) LIKE '<environment_context>%'
+	)`
+}
+
+func toFTSQuery(query string) string {
+	terms := strings.Fields(query)
+	if len(terms) == 0 {
+		return `""`
+	}
+	escaped := make([]string, 0, len(terms))
+	for _, term := range terms {
+		term = strings.Trim(term, `"`)
+		term = strings.ReplaceAll(term, `"`, `""`)
+		escaped = append(escaped, `"`+term+`"`)
+	}
+	return strings.Join(escaped, " AND ")
+}
+
+func defaultDBPath() string {
+	if value := os.Getenv("GORA_DB"); value != "" {
+		return expandHome(value)
+	}
+	if value := os.Getenv("XDG_DATA_HOME"); value != "" {
+		return filepath.Join(expandHome(value), "gora", "history.sqlite")
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "history.sqlite"
+	}
+	if runtime.GOOS == "darwin" {
+		return filepath.Join(home, "Library", "Application Support", "gora", "history.sqlite")
+	}
+	return filepath.Join(home, ".local", "share", "gora", "history.sqlite")
+}
+
+func expandHome(path string) string {
+	if path == "~" {
+		home, _ := os.UserHomeDir()
+		return home
+	}
+	if strings.HasPrefix(path, "~/") {
+		home, _ := os.UserHomeDir()
+		return filepath.Join(home, path[2:])
+	}
+	return path
+}
+
+func providerStyle(provider string, selectedRow bool) lipgloss.Style {
+	providerColor := cyan
+	switch provider {
+	case "codex":
+		providerColor = purple
+	case "pi":
+		providerColor = green
+	case "claude":
+		providerColor = cyan
+	}
+	return lipgloss.NewStyle().Foreground(providerColor).Background(bg).Bold(selectedRow)
+}
+
+func roleStyle(role string) lipgloss.Style {
+	switch role {
+	case "user":
+		return lipgloss.NewStyle().Foreground(cyan).Background(bg).Bold(true)
+	case "assistant":
+		return lipgloss.NewStyle().Foreground(purple).Background(bg).Bold(true)
+	case "tool-call":
+		return lipgloss.NewStyle().Foreground(green).Background(bg).Bold(true)
+	case "tool":
+		return lipgloss.NewStyle().Foreground(yellow).Background(bg).Bold(true)
+	case "system", "developer":
+		return lipgloss.NewStyle().Foreground(red).Background(bg).Bold(true)
+	default:
+		return lipgloss.NewStyle().Foreground(green).Background(bg).Bold(true)
+	}
+}
+
+func providerBadge(provider string) string {
+	if provider == "claude" {
+		return "Claude"
+	}
+	return providerLabel(provider)
+}
+
+func providerLabel(provider string) string {
+	switch provider {
+	case "codex":
+		return "Codex"
+	case "claude":
+		return "Claude Code"
+	case "pi":
+		return "Pi"
+	default:
+		return provider
+	}
+}
+
+func modelSummary(models string) string {
+	if models == "" {
+		return ""
+	}
+	parts := strings.Split(models, ",")
+	if len(parts) <= 1 {
+		return models
+	}
+	return parts[0] + fmt.Sprintf(" +%d", len(parts)-1)
+}
+
+func friendlyTime(value string) string {
+	if value == "" {
+		return "-"
+	}
+	if parsed, err := parseTime(value); err == nil {
+		return parsed.Format("2006-01-02 15:04")
+	}
+	if parts := strings.SplitN(value, "T", 2); len(parts) == 2 {
+		timePart := strings.TrimSuffix(parts[1], "Z")
+		if len(timePart) >= 5 {
+			return parts[0] + " " + timePart[:5]
+		}
+		return parts[0] + " " + timePart
+	}
+	return value
+}
+
+func relativeTime(value string) string {
+	parsed, err := parseTime(value)
+	if err != nil {
+		return "-"
+	}
+	delta := time.Since(parsed)
+	if delta < time.Minute {
+		return "now"
+	}
+	if delta < time.Hour {
+		return fmt.Sprintf("%dm ago", int(delta.Minutes()))
+	}
+	if delta < 24*time.Hour {
+		return fmt.Sprintf("%dh ago", int(delta.Hours()))
+	}
+	days := int(delta.Hours() / 24)
+	if days < 90 {
+		return fmt.Sprintf("%dd ago", days)
+	}
+	weeks := days / 7
+	if weeks < 52 {
+		return fmt.Sprintf("%dw ago", weeks)
+	}
+	return fmt.Sprintf("%dy ago", days/365)
+}
+
+func parseTime(value string) (time.Time, error) {
+	if value == "" {
+		return time.Time{}, errors.New("empty time")
+	}
+	if parsed, err := time.Parse(time.RFC3339Nano, value); err == nil {
+		return parsed, nil
+	}
+	return time.Parse("2006-01-02T15:04:05", strings.TrimSuffix(value, "Z"))
+}
+
+func shortCwd(cwd string) string {
+	if cwd == "" {
+		return "no repo"
+	}
+	parts := strings.Split(filepath.Clean(cwd), string(filepath.Separator))
+	if len(parts) <= 3 {
+		return cwd
+	}
+	return filepath.Join(parts[len(parts)-3:]...)
+}
+
+func oneLine(text string) string {
+	withoutImages := imageTagPattern.ReplaceAllString(text, " ")
+	cleaned := strings.Join(strings.Fields(withoutImages), " ")
+	if cleaned == "" && imageTagPattern.MatchString(text) {
+		return "image attachment"
+	}
+	return cleaned
+}
+
+func padRight(text string, width int) string {
+	runes := []rune(text)
+	if len(runes) >= width {
+		return string(runes[:width])
+	}
+	return text + strings.Repeat(" ", width-len(runes))
+}
+
+func fit(text string, width int) string {
+	if width <= 0 {
+		return ""
+	}
+	runes := []rune(text)
+	if len(runes) <= width {
+		return text
+	}
+	if width <= 3 {
+		return string(runes[:width])
+	}
+	return string(runes[:width-3]) + "..."
+}
+
+func wrap(text string, width int) []string {
+	text = strings.TrimRight(text, "\r")
+	if text == "" {
+		return []string{""}
+	}
+	words := strings.Fields(text)
+	if len(words) == 0 {
+		return []string{""}
+	}
+	lines := []string{}
+	current := ""
+	for _, word := range words {
+		if current == "" {
+			current = word
+			continue
+		}
+		if len([]rune(current))+1+len([]rune(word)) > width {
+			lines = append(lines, current)
+			current = word
+			continue
+		}
+		current += " " + word
+	}
+	if current != "" {
+		lines = append(lines, current)
+	}
+	return lines
+}
+
+func clamp(value int, low int, high int) int {
+	if value < low {
+		return low
+	}
+	if value > high {
+		return high
+	}
+	return value
+}
+
+func min(left int, right int) int {
+	if left < right {
+		return left
+	}
+	return right
+}
+
+func max(left int, right int) int {
+	if left > right {
+		return left
+	}
+	return right
+}