"math/rand"

	}
}
func TestSampling(t *testing.T) {
	makeSegs := func(n int) []*utils.Segment {
		s := make([]*utils.Segment, n)
		for i := range s {
			s[i] = &utils.Segment{StartTime: float64(i), EndTime: float64(i + 1)}
		}
		return s
	}
	df1 := &utils.DataFile{FilePath: "/test/f1.data", Segments: makeSegs(6)}
	df2 := &utils.DataFile{FilePath: "/test/f2.data", Segments: makeSegs(4)}
	kept := []*utils.DataFile{df1, df2}
	cached := [][]*utils.Segment{df1.Segments, df2.Segments}
	countTotal := func(c [][]*utils.Segment) int {
		n := 0
		for _, s := range c {
			n += len(s)
		}
		return n
	}
	// 50% of 10 → 5
	k, c := applySampling(kept, cached, 50, rand.New(rand.NewSource(42)))
	if got := countTotal(c); got != 5 {
		t.Errorf("sample 50%%: expected 5, got %d", got)
	}
	// Files must be in original chronological order
	for i := 1; i < len(k); i++ {
		if k[i].FilePath < k[i-1].FilePath {
			t.Errorf("sample 50%%: files out of order at index %d", i)
		}

	// 10% of 10 → 1
	_, c2 := applySampling(kept, cached, 10, rand.New(rand.NewSource(42)))
	if got := countTotal(c2); got != 1 {
		t.Errorf("sample 10%%: expected 1, got %d", got)
	}
	// 1% of 10 → clamp to 1
	_, c3 := applySampling(kept, cached, 1, rand.New(rand.NewSource(42)))
	if got := countTotal(c3); got != 1 {
		t.Errorf("sample 1%%: expected 1 (clamped), got %d", got)
	}
	// 99% of 10 → 9
	_, c4 := applySampling(kept, cached, 99, rand.New(rand.NewSource(42)))
	if got := countTotal(c4); got != 9 {
		t.Errorf("sample 99%%: expected 9, got %d", got)
	}

	"math/rand"

	"time"

	Sample    int    // random sample percentage 1-99, -1 = no sampling, 100 = no-op

	// Phase 4 - Random sampling (last filter step, preserves chronological order)
	if config.Sample > 0 && config.Sample < 100 {
		rng := rand.New(rand.NewSource(time.Now().UnixNano()))
		kept, cachedSegs = applySampling(kept, cachedSegs, config.Sample, rng)
	}

// applySampling randomly selects sample% of segments from the filtered set.
// The returned files and segments preserve the original chronological order.
func applySampling(kept []*utils.DataFile, cachedSegs [][]*utils.Segment, sample int, rng *rand.Rand) ([]*utils.DataFile, [][]*utils.Segment) {
	flat := make([]struct{ fileIdx, segIdx int }, 0)
	for fi, segs := range cachedSegs {
		for si := range segs {
			flat = append(flat, struct{ fileIdx, segIdx int }{fi, si})
		}
	}

	targetCount := len(flat) * sample / 100
	if targetCount < 1 {
		targetCount = 1
	}
	rng.Shuffle(len(flat), func(i, j int) { flat[i], flat[j] = flat[j], flat[i] })
	selected := flat[:targetCount]
	// Restore chronological order before rebuilding
	sort.Slice(selected, func(i, j int) bool {
		if selected[i].fileIdx != selected[j].fileIdx {
			return selected[i].fileIdx < selected[j].fileIdx
		}
		return selected[i].segIdx < selected[j].segIdx
	})
	newCached := make([][]*utils.Segment, len(cachedSegs))
	for _, ref := range selected {
		newCached[ref.fileIdx] = append(newCached[ref.fileIdx], cachedSegs[ref.fileIdx][ref.segIdx])
	}
	var newKept []*utils.DataFile
	var finalCached [][]*utils.Segment
	for i, segs := range newCached {
		if len(segs) > 0 {
			newKept = append(newKept, kept[i])
			finalCached = append(finalCached, segs)
		}
	}
	return newKept, finalCached
}

day  -> civil sunrise to !!civil sunset!!
claude --resume "reject-reserved-key-bindings"
Anomalies 
File by file 
List of models rpecies
Similar clips with diff label
Cert 70

sample in tui only

Push cert 90 to 100, cli, undocumented
Species calltype
multi label in tui. How?? also cli

	fmt.Fprintf(os.Stderr, "  --sample <1-100>      Randomly sample N%% of filtered calls (requires --certainty; 100 = no-op)\n")

	var certainty int

	var certainty, sample int

	// Default to -1 (no certainty filter)

	// Default to -1 (no filter / no sampling)

	sample = -1

		case "--sample":
			if i+1 >= len(args) {
				fmt.Fprintf(os.Stderr, "Error: --sample requires a value\n")
				os.Exit(1)
			}
			v, err := strconv.Atoi(args[i+1])
			if err != nil {
				fmt.Fprintf(os.Stderr, "Error: --sample must be an integer\n")
				os.Exit(1)
			}
			if v <= 0 || v > 100 {
				fmt.Fprintf(os.Stderr, "Error: --sample must be between 1 and 100\n")
				os.Exit(1)
			}
			sample = v
			i += 2

	// --sample 1-99 requires --certainty; --sample 100 is a no-op
	if sample > 0 && sample < 100 && certainty < 0 {
		fmt.Fprintf(os.Stderr, "Error: --sample requires --certainty to be set\n")
		os.Exit(1)
	}

		Sample:    sample,