Bookmark  bool           // user bookmark for navigation

	}
	if v, ok := obj["bookmark"].(bool); ok {
		label.Bookmark = v
		delete(obj, "bookmark")

			}
			if label.Bookmark {
				l["bookmark"] = true

	case "ctrl+d":
		// Toggle bookmark
		m.state.ToggleBookmark()
		if err := m.state.Save(); err != nil {
			m.err = err.Error()
		}
		return m, nil
	case "ctrl+n":
		// Next bookmark
		if m.state.Player != nil {
			m.state.Player.Stop()
		}
		if m.state.NextBookmark() {
			return m, m.segmentChangeCmd()
		}
		m.err = "No bookmarks found"
		return m, nil
	case "ctrl+p":
		// Previous bookmark
		if m.state.Player != nil {
			m.state.Player.Stop()
		}
		if m.state.PrevBookmark() {
			return m, m.segmentChangeCmd()
		}
		m.err = "No bookmarks found"
		return m, nil

	b.WriteString(helpStyle.Render("[esc]quit [,]prev [.]next [space]comment [enter]play [shift+enter]½speed"))

	b.WriteString(helpStyle.Render("[esc]quit [,]prev [.]next [space]comment [ctrl+d]bookmark [ctrl+n]next-bk [ctrl+p]prev-bk [enter]play [shift+enter]½speed"))

	if m.state.HasBookmark() {
		segInfo += " [BOOKMARKED]"
	}

}
// getFilterLabel returns the label matching the current filter, or first label if no filter.
func (s *ClassifyState) getFilterLabel(seg *utils.Segment) *utils.Label {
	if s.Config.Filter == "" {
		if len(seg.Labels) > 0 {
			return seg.Labels[0]
		}
		return nil
	}
	for _, label := range seg.Labels {
		if label.Filter == s.Config.Filter {
			return label
		}
	}
	return nil
}
// getOrCreateFilterLabel gets existing label or creates new one for the current filter.
func (s *ClassifyState) getOrCreateFilterLabel(seg *utils.Segment) *utils.Label {
	label := s.getFilterLabel(seg)
	if label != nil {
		return label
	}
	// Create new label
	label = &utils.Label{
		Species:   "Don't Know",
		Certainty: 0,
		Filter:    s.Config.Filter,
	}
	seg.Labels = append(seg.Labels, label)
	s.Dirty = true
	return label
}
// HasBookmark returns true if current segment has a bookmark on the filter label.
func (s *ClassifyState) HasBookmark() bool {
	seg := s.CurrentSegment()
	if seg == nil {
		return false
	}
	label := s.getFilterLabel(seg)
	return label != nil && label.Bookmark
}
// ToggleBookmark toggles the bookmark on the current segment's filter label.
func (s *ClassifyState) ToggleBookmark() {
	seg := s.CurrentSegment()
	if seg == nil {
		return
	}
	df := s.CurrentFile()
	if df == nil {
		return
	}
	// Set reviewer
	df.Meta.Reviewer = s.Config.Reviewer
	label := s.getOrCreateFilterLabel(seg)
	label.Bookmark = !label.Bookmark
	s.Dirty = true
}
// NextBookmark navigates to the next bookmark, wrapping around if needed.
// Returns false if no bookmarks found (back at start position).
func (s *ClassifyState) NextBookmark() bool {
	startFile := s.FileIdx
	startSeg := s.SegmentIdx
	first := true
	for {
		// Advance to next segment
		if !s.nextSegmentRaw() {
			// Wrap to start of folder
			s.FileIdx = 0
			s.SegmentIdx = 0
		}
		// Check if we've looped back to start
		if !first && s.FileIdx == startFile && s.SegmentIdx == startSeg {
			return false // full circle, no bookmark found
		}
		first = false
		// Check if current segment has bookmark
		if s.hasFilterBookmark() {
			return true
		}
	}

// PrevBookmark navigates to the previous bookmark, wrapping around if needed.
// Returns false if no bookmarks found (back at start position).
func (s *ClassifyState) PrevBookmark() bool {
	startFile := s.FileIdx
	startSeg := s.SegmentIdx
	first := true

	for {
		// Move to previous segment
		if !s.prevSegmentRaw() {
			// Wrap to end of folder
			s.FileIdx = len(s.DataFiles) - 1
			df := s.DataFiles[s.FileIdx]
			segs := s.getFilteredSegments(df)
			s.SegmentIdx = max(len(segs)-1, 0)
		}
		// Check if we've looped back to start
		if !first && s.FileIdx == startFile && s.SegmentIdx == startSeg {
			return false // full circle, no bookmark found
		}
		first = false
		// Check if current segment has bookmark
		if s.hasFilterBookmark() {
			return true
		}
	}
}
// nextSegmentRaw moves to next segment without wrapping, returns false if at end.
func (s *ClassifyState) nextSegmentRaw() bool {
	df := s.CurrentFile()
	if df == nil {
		return false
	}
	segs := s.getFilteredSegments(df)
	if s.SegmentIdx+1 < len(segs) {
		s.SegmentIdx++
		return true
	}
	// Move to next file
	if s.FileIdx+1 < len(s.DataFiles) {
		s.FileIdx++
		s.SegmentIdx = 0
		return true
	}
	return false
}
// prevSegmentRaw moves to previous segment without wrapping, returns false if at start.
func (s *ClassifyState) prevSegmentRaw() bool {
	if s.SegmentIdx > 0 {
		s.SegmentIdx--
		return true
	}
	// Move to previous file
	if s.FileIdx > 0 {
		s.FileIdx--
		df := s.CurrentFile()
		segs := s.getFilteredSegments(df)
		s.SegmentIdx = max(len(segs)-1, 0)
		return true
	}
	return false
}
// hasFilterBookmark checks if current segment has bookmark on filter-matching label.
func (s *ClassifyState) hasFilterBookmark() bool {
	seg := s.CurrentSegment()
	if seg == nil {
		return false
	}
	return s.segmentHasBookmark(seg)
}
// segmentHasBookmark checks if a segment has a bookmark on filter-matching label.
func (s *ClassifyState) segmentHasBookmark(seg *utils.Segment) bool {
	label := s.getFilterLabel(seg)
	return label != nil && label.Bookmark
}

./skraak calls classify --folder 2024-05-06 --reviewer David --color --img-dims 600 \

./skraak calls classify --folder 2024-05-06 --reviewer David --color \

  --bind v=brncre, \

## [2026-03-09] Bookmark Navigation in TUI
**New feature:** Bookmark segments for later review.
**Changes:**
- `utils/data_file.go` — Added `Bookmark bool` to Label struct
- `tools/calls_classify.go` — Added bookmark methods
- `tui/classify.go` — Added key handlers and display
**Format** (stored in label):
```json
[0, 3, 0, 16000, [{"species": "Kiwi", "certainty": 90, "filter": "BirdNET", "bookmark": true}]]
```
**Key bindings:**
| Key | Action |
|-----|--------|
| `Ctrl+D` | Toggle bookmark on current segment |
| `Ctrl+N` | Navigate to next bookmark (wraps around) |
| `Ctrl+P` | Navigate to previous bookmark (wraps around) |

**Behavior:**
- Bookmark lives on the filter-matching label
- `--filter BirdNET` shows bookmarks on BirdNET labels only
- No filter shows all bookmarks
- Wrap-around navigation with loop detection
- `[BOOKMARKED]` indicator shown in segment info