quietlight/skraak_mcp - Change RUF5K5CL542GK5UIIIBHPIMGGCXU72IWS5OFBVTI5DRX36OSPJDAC

removed ctrl-g goto in tui, added simpler --goto flag, fixed recalcualte list on classification step, hopefully

Created by quietlight on April 4, 2026

RUF5K5CL542GK5UIIIBHPIMGGCXU72IWS5OFBVTI5DRX36OSPJDAC

Dependencies

In channels

main

Change contents

Deletion in tui/classify.go at line 110 [7.9978]

B:BD[5.192] → [6.35:151]


	// Goto dialog state
	gotoMode  bool   // true when goto mode is active
	gotoInput string // current number input

Deletion in tui/classify.go at line 180 [7.9978]

B:BD[8.2026] → [6.152:246]

	}
	// If in goto mode, route to goto handler
	if m.gotoMode {
		return m.handleGotoKey(msg)

Deletion in tui/classify.go at line 220 [7.9978]

B:BD[9.228] → [6.247:357]

B:BD[6.357] → [10.266:286]

	// Check for Ctrl+G (goto file dialog)
	if msg.String() == "ctrl+g" {
		m.gotoInput = ""
		m.gotoMode = true
		return m, nil
	}

Deletion in tui/classify.go at line 378 [7.9978]

B:BD[5.1533] → [6.378:964]

		}
		return m, nil
	}
	return m, nil
}
// handleGotoKey handles key presses in goto mode
func (m Model) handleGotoKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	key := msg.Key()
	// Enter: execute goto
	if key.Code == tea.KeyEnter {
		if m.gotoInput == "" {
			m.gotoMode = false
			return m, nil
		}
		fileNum := 0
		for _, ch := range m.gotoInput {
			if ch >= '0' && ch <= '9' {
				fileNum = fileNum*10 + int(ch-'0')
			}
		}
		if m.state.GotoFile(fileNum) {
			if m.state.Player != nil {
				m.state.Player.Stop()
			}
			m.gotoMode = false
			return m, m.segmentChangeCmd()

Deletion in tui/classify.go at line 379 [7.9978]

B:BD[7.12806] → [6.965:1166]

		m.err = fmt.Sprintf("Invalid file number: %s", m.gotoInput)
		m.gotoMode = false
		return m, nil
	}
	// Escape: cancel
	if key.Code == tea.KeyEscape || key.Code == tea.KeyEsc {
		m.gotoMode = false

Deletion in tui/classify.go at line 382 [7.9978]

B:BD[8.3094] → [6.1167:1553]

B:BD[6.1553] → [10.397:421]

	// Backspace: remove last digit
	if key.Code == tea.KeyBackspace {
		if len(m.gotoInput) > 0 {
			m.gotoInput = m.gotoInput[:len(m.gotoInput)-1]
		}
		return m, nil
	}
	// Digits: append to input
	s := msg.String()
	if len(s) == 1 && s[0] >= '0' && s[0] <= '9' {
		// Limit to reasonable number of digits (9 digits = 999,999,999 files)
		if len(m.gotoInput) < 9 {
			m.gotoInput += s
		}
		return m, nil
	}

Replacement in tui/classify.go at line 605 [7.9978]

B:BD[11.433] → [10.4127:4337]

	b.WriteString(helpDarkStyle.Render(wrapText("[esc]quit [,]prev [.]next [space]comment [ctrl+s]clip [ctrl+g]goto [ctrl+d]bookmark [ctrl+,]prev-bk [ctrl+.]next-bk [enter]play [shift+enter]½speed", wrapWidth)))

[11.433]

[11.494]

	b.WriteString(helpDarkStyle.Render(wrapText("[esc]quit [,]prev [.]next [space]comment [ctrl+s]clip [ctrl+d]bookmark [ctrl+,]prev-bk [ctrl+.]next-bk [enter]play [shift+enter]½speed", wrapWidth)))

Deletion in tui/classify.go at line 645 [7.9978]

B:BD[7.14865] → [6.1776:1885]


	// Goto dialog (when active)
	if m.gotoMode {
		m.renderGotoDialog(&b)
		return tea.NewView(b.String())
	}

Deletion in tui/classify.go at line 687 [7.9978]

B:BD[8.3781] → [6.1886:2104]


// renderGotoDialog renders the goto file input dialog
func (m Model) renderGotoDialog(b *strings.Builder) {
	inputLine := m.gotoInput + "█"
	totalFiles := m.state.TotalFiles()
	helpLine := "[enter]go  [esc]cancel"

Deletion in tui/classify.go at line 688 [7.9978]

B:BD[8.3782] → [6.2105:2254]

	// Render box
	content := fmt.Sprintf("Go to file:\n%s/%d\n%s", inputLine, totalFiles, helpLine)
	b.WriteString(commentBoxStyle.Render(content))
}

Replacement in tools/calls_classify_test.go at line 17 [7.15273]

B:BD[7.15569] → [7.15569:15644]

	state := &ClassifyState{
		Config: ClassifyConfig{Bindings: bindings},
	}

[7.15569]

[7.15644]

	state := NewClassifyState(ClassifyConfig{Bindings: bindings, Certainty: -1}, nil)

Replacement in tools/calls_classify_test.go at line 72 [7.15273]

B:BD[7.17311] → [7.17311:17363]

B:BD[7.17363] → [2.3067:3161]

∅:D[2.3161] → [7.17436:17441]

B:BD[7.17436] → [7.17436:17441]

B:BD[7.17441] → [12.4030:4084]

∅:D[12.4084] → [7.17493:17513]

B:BD[7.17493] → [7.17493:17513]

	state := &ClassifyState{
		Config: ClassifyConfig{
			Filter:    "test-filter",
			Reviewer:  "David",
			Bindings:  bindings,
			Certainty: -1,
		},
		DataFiles:  []*utils.DataFile{df},
		FileIdx:    0,
		SegmentIdx: 0,
	}

[7.17311]

[7.17513]

	state := NewClassifyState(ClassifyConfig{
		Filter:    "test-filter",
		Reviewer:  "David",
		Bindings:  bindings,
		Certainty: -1,
	}, []*utils.DataFile{df})

Replacement in tools/calls_classify_test.go at line 138 [7.15273]

B:BD[7.20078] → [7.20078:20130]

B:BD[7.20130] → [2.3162:3256]

∅:D[2.3256] → [7.20203:20208]

B:BD[7.20203] → [7.20203:20208]

B:BD[7.20208] → [12.4849:4903]

∅:D[12.4903] → [7.20260:20280]

B:BD[7.20260] → [7.20260:20280]

	state := &ClassifyState{
		Config: ClassifyConfig{
			Filter:    "test-filter",
			Reviewer:  "David",
			Bindings:  bindings,
			Certainty: -1,
		},
		DataFiles:  []*utils.DataFile{df},
		FileIdx:    0,
		SegmentIdx: 0,
	}

[7.20078]

[7.20280]

	state := NewClassifyState(ClassifyConfig{
		Filter:    "test-filter",
		Reviewer:  "David",
		Bindings:  bindings,
		Certainty: -1,
	}, []*utils.DataFile{df})

Replacement in tools/calls_classify_load_test.go at line 114 [13.1]

B:BD[13.3801] → [13.3801:3862]

	// but getFilteredSegments should return only the Kiwi ones

[13.3801]

[13.3862]

	// but cached filtered segments should return only the Kiwi ones

Replacement in tools/calls_classify_load_test.go at line 119 [13.1]

B:BD[13.4009] → [13.4009:4180]

	filtered := state.getFilteredSegments(state.DataFiles[0])
	if len(filtered) != 2 {
		t.Errorf("getFilteredSegments should return 2 Kiwi segments, got %d", len(filtered))

[13.4009]

[13.4180]

	// TotalSegments uses cached filtered segments
	if state.TotalSegments() != 2 {
		t.Errorf("TotalSegments should return 2 Kiwi segments, got %d", state.TotalSegments())

Replacement in tools/calls_classify_filter_test.go at line 45 [13.5379]
B:BD[13.6185] → [13.6185:6212]
B:BD[13.6212] → [2.3711:3755]
∅:D[2.3755] → [13.6243:6288]
B:BD[13.6243] → [13.6243:6288]
```
	state1 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: -1},
		DataFiles: []*utils.DataFile{df1, df2},
	}
```
[13.6185]
[13.6288]
```
	state1 := NewClassifyState(ClassifyConfig{Certainty: -1}, []*utils.DataFile{df1, df2})
```

Replacement in tools/calls_classify_filter_test.go at line 51 [13.5379]

B:BD[13.6472] → [13.6472:6499]

B:BD[13.6499] → [2.3756:3817]

∅:D[2.3817] → [13.6545:6590]

B:BD[13.6545] → [13.6545:6590]

	state2 := &ClassifyState{
		Config:    ClassifyConfig{Species: "Kiwi", Certainty: -1},
		DataFiles: []*utils.DataFile{df1, df2},
	}

[13.6472]

[13.6590]

	state2 := NewClassifyState(ClassifyConfig{Species: "Kiwi", Certainty: -1}, []*utils.DataFile{df1, df2})

Replacement in tools/calls_classify_filter_test.go at line 57 [13.5379]

B:BD[13.6780] → [13.6780:6807]

B:BD[13.6807] → [2.3818:3881]

∅:D[2.3881] → [13.6855:6900]

B:BD[13.6855] → [13.6855:6900]

	state3 := &ClassifyState{
		Config:    ClassifyConfig{Species: "Tomtit", Certainty: -1},
		DataFiles: []*utils.DataFile{df1, df2},
	}

[13.6780]

[13.6900]

	state3 := NewClassifyState(ClassifyConfig{Species: "Tomtit", Certainty: -1}, []*utils.DataFile{df1, df2})

Replacement in tools/calls_classify_filter_test.go at line 63 [13.5379]

B:BD[13.7090] → [13.7090:7117]

B:BD[13.7117] → [2.3882:3947]

∅:D[2.3947] → [13.7167:7212]

B:BD[13.7167] → [13.7167:7212]

	state4 := &ClassifyState{
		Config:    ClassifyConfig{Filter: "model-1.0", Certainty: -1},
		DataFiles: []*utils.DataFile{df1, df2},
	}

[13.7090]

[13.7212]

	state4 := NewClassifyState(ClassifyConfig{Filter: "model-1.0", Certainty: -1}, []*utils.DataFile{df1, df2})

Replacement in tools/calls_classify_filter_test.go at line 69 [13.5379]

B:BD[13.7387] → [13.7387:7414]

B:BD[13.7414] → [2.3948:4016]

∅:D[2.4016] → [13.7467:7512]

B:BD[13.7467] → [13.7467:7512]

	state5 := &ClassifyState{
		Config:    ClassifyConfig{Species: "NonExistent", Certainty: -1},
		DataFiles: []*utils.DataFile{df1, df2},
	}

[13.7387]

[13.7512]

	state5 := NewClassifyState(ClassifyConfig{Species: "NonExistent", Certainty: -1}, []*utils.DataFile{df1, df2})

Deletion in tools/calls_classify_filter_test.go at line 93 [13.5379]
B:BD[13.8053] → [13.8053:8083]
B:BD[13.8083] → [2.4017:4099]
∅:D[2.4099] → [13.8150:8187]
B:BD[13.8150] → [13.8150:8187]
```
	}
	state6 := &ClassifyState{
		Config:    ClassifyConfig{Filter: "model-1.0", Species: "Kiwi", Certainty: -1},
		DataFiles: []*utils.DataFile{df3},
```

Insertion in tools/calls_classify_filter_test.go at line 94 [13.5379]

[13.8190]

	state6 := NewClassifyState(ClassifyConfig{Filter: "model-1.0", Species: "Kiwi", Certainty: -1}, []*utils.DataFile{df3})

Replacement in tools/calls_classify_filter_test.go at line 137 [13.5379]

B:BD[13.9120] → [13.9120:9146]

B:BD[13.9146] → [2.4100:4162]

∅:D[2.4162] → [13.9193:9283]

B:BD[13.9193] → [13.9193:9283]

	state := &ClassifyState{
		Config:     ClassifyConfig{Species: "Kiwi", Certainty: -1},
		DataFiles:  []*utils.DataFile{df1, df2},
		FileIdx:    1, // at df2
		SegmentIdx: 0,
	}

[13.9120]

[13.9283]

	state := NewClassifyState(ClassifyConfig{Species: "Kiwi", Certainty: -1}, []*utils.DataFile{df1, df2})
	state.FileIdx = 1    // at df2
	state.SegmentIdx = 0

Replacement in tools/calls_classify_filter_test.go at line 176 [13.5379]

B:BD[2.4860] → [2.4860:4970]

	state1 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 70},
		DataFiles: []*utils.DataFile{df},
	}

[2.4860]

[2.4970]

	state1 := NewClassifyState(ClassifyConfig{Certainty: 70}, []*utils.DataFile{df})

Replacement in tools/calls_classify_filter_test.go at line 182 [13.5379]

B:BD[2.5140] → [2.5140:5251]

	state2 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 100},
		DataFiles: []*utils.DataFile{df},
	}

[2.5140]

[2.5251]

	state2 := NewClassifyState(ClassifyConfig{Certainty: 100}, []*utils.DataFile{df})

Replacement in tools/calls_classify_filter_test.go at line 188 [13.5379]

B:BD[2.5420] → [2.5420:5529]

	state3 := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 0},
		DataFiles: []*utils.DataFile{df},
	}

[2.5420]

[2.5529]

	state3 := NewClassifyState(ClassifyConfig{Certainty: 0}, []*utils.DataFile{df})

Replacement in tools/calls_classify_filter_test.go at line 194 [13.5379]

B:BD[2.5680] → [2.5680:5804]

∅:D[2.5804] → [13.9422:9425]

B:BD[13.9422] → [13.9422:9425]

	state4 := &ClassifyState{
		Config:    ClassifyConfig{Species: "Kiwi", Certainty: 70},
		DataFiles: []*utils.DataFile{df},
	}

[2.5680]

[2.5805]

	state4 := NewClassifyState(ClassifyConfig{Species: "Kiwi", Certainty: 70}, []*utils.DataFile{df})

Replacement in tools/calls_classify_filter_test.go at line 230 [13.5379]

B:BD[3.1997] → [3.1997:2113]

	state := &ClassifyState{
		Config:    ClassifyConfig{Certainty: 100},
		DataFiles: []*utils.DataFile{df1, df2},
	}

[3.1997]

[3.2113]

	state := NewClassifyState(ClassifyConfig{Certainty: 100}, []*utils.DataFile{df1, df2})

Insertion in tools/calls_classify.go at line 27 [7.20592]

[2.6009]

[14.819]

	Goto      string // goto this file on startup (optional, basename match)

Insertion in tools/calls_classify.go at line 40 [7.20592]

[15.5530]

	filteredSegs  [][]*utils.Segment // cached at load time, parallel to DataFiles

Insertion in tools/calls_classify.go at line 91 [7.20592]

[7.22406]


	// Compute filtered segments once, remove files with no matches
	hasFilter := config.Filter != "" || config.Species != "" || config.Certainty >= 0
	var kept []*utils.DataFile
	var cachedSegs [][]*utils.Segment

Insertion in tools/calls_classify.go at line 97 [7.20592]

[7.22407]

[16.60]

	for _, df := range dataFiles {
		var segs []*utils.Segment
		if !hasFilter {
			segs = df.Segments
		} else {
			for _, seg := range df.Segments {
				if seg.SegmentMatchesFilters(config.Filter, config.Species, config.CallType, config.Certainty) {
					segs = append(segs, seg)
				}
			}
			if len(segs) == 0 {
				continue // skip files with no matching segments
			}
		}
		kept = append(kept, df)
		cachedSegs = append(cachedSegs, segs)
	}

Replacement in tools/calls_classify.go at line 116 [7.20592]
∅:D[16.86] → [7.22431:22476]
B:BD[7.22431] → [7.22431:22476]
```
		Config:    config,
		DataFiles: dataFiles,
```
[16.86]
[16.87]
```
		Config:       config,
		DataFiles:    kept,
		filteredSegs: cachedSegs,
```

Replacement in tools/calls_classify.go at line 121 [7.20592]

B:BD[16.91] → [16.91:196]

B:BD[16.196] → [3.2461:2536]

∅:D[3.2536] → [16.246:395]

B:BD[16.246] → [16.246:395]

	// When filtering, remove files with no matching segments
	// so navigation doesn't land on empty files
	if config.Filter != "" || config.Species != "" || config.Certainty >= 0 {
		var matching []*utils.DataFile
		for _, df := range dataFiles {
			if len(state.getFilteredSegments(df)) > 0 {
				matching = append(matching, df)

[16.91]

[16.395]

	// Handle --goto: find file by basename and set initial position
	if config.Goto != "" {
		found := false
		for i, df := range state.DataFiles {
			base := df.FilePath[strings.LastIndex(df.FilePath, "/")+1:]
			if base == config.Goto {
				state.FileIdx = i
				found = true
				break

Replacement in tools/calls_classify.go at line 132 [7.20592]

B:BD[16.404] → [16.404:433]

		state.DataFiles = matching

[16.404]

[16.433]

		if !found {
			return nil, fmt.Errorf("goto file not found (or has no matching segments): %s", config.Goto)
		}

Insertion in tools/calls_classify.go at line 138 [7.20592]

[16.456]

[7.22484]

}
// NewClassifyState creates a ClassifyState with pre-computed filtered segments.
// Used by tests that construct state directly without LoadDataFiles.
func NewClassifyState(config ClassifyConfig, dataFiles []*utils.DataFile) *ClassifyState {
	hasFilter := config.Filter != "" || config.Species != "" || config.Certainty >= 0
	cached := make([][]*utils.Segment, len(dataFiles))
	for i, df := range dataFiles {
		if !hasFilter {
			cached[i] = df.Segments
		} else {
			for _, seg := range df.Segments {
				if seg.SegmentMatchesFilters(config.Filter, config.Species, config.CallType, config.Certainty) {
					cached[i] = append(cached[i], seg)
				}
			}
		}
	}
	return &ClassifyState{
		Config:       config,
		DataFiles:    dataFiles,
		filteredSegs: cached,
	}

Deletion in tools/calls_classify.go at line 169 [7.20592]

B:BD[7.22671] → [6.2280:2404]

}
// TotalFiles returns the total number of data files
func (s *ClassifyState) TotalFiles() int {
	return len(s.DataFiles)

Deletion in tools/calls_classify.go at line 171 [7.20592]

B:BD[6.2407] → [6.2407:2667]

∅:D[6.2667] → [7.22671:22674]

B:BD[7.22671] → [7.22671:22674]

// GotoFile jumps to a specific file number (1-based), returns false if invalid
func (s *ClassifyState) GotoFile(fileNum int) bool {
	idx := fileNum - 1
	if idx < 0 || idx >= len(s.DataFiles) {
		return false
	}
	s.FileIdx = idx
	s.SegmentIdx = 0
	return true
}

Replacement in tools/calls_classify.go at line 173 [7.20592]
B:BD[7.22778] → [7.22778:22817]
```
	df := s.CurrentFile()
	if df == nil {
```
[7.22778]
[7.22817]
```
	if s.FileIdx >= len(s.filteredSegs) {
```

Replacement in tools/calls_classify.go at line 176 [7.20592]

B:BD[7.22833] → [7.22833:22947]


	// Get segments with matching filter
	segments := s.getFilteredSegments(df)
	if s.SegmentIdx >= len(segments) {

[7.22833]

[7.22947]

	segs := s.filteredSegs[s.FileIdx]
	if s.SegmentIdx >= len(segs) {

Replacement in tools/calls_classify.go at line 180 [7.20592]
B:BD[7.22963] → [7.22963:22994]
```
	return segments[s.SegmentIdx]
```
[7.22963]
[7.22994]
```
	return segs[s.SegmentIdx]
```
Deletion in tools/calls_classify.go at line 182 [7.20592]
B:BD[7.22996] → [7.22996:22997]
B:BD[7.22997] → [2.6010:6117]
∅:D[17.281] → [7.23057:23140]
∅:D[2.6117] → [7.23057:23140]
B:BD[7.23057] → [7.23057:23140]
B:BD[7.23140] → [2.6118:6198]
∅:D[17.336] → [7.23168:23192]
∅:D[2.6198] → [7.23168:23192]
B:BD[7.23168] → [7.23168:23192]
```
// getFilteredSegments returns segments matching the active filters (filter, species, calltype, certainty)
func (s *ClassifyState) getFilteredSegments(df *utils.DataFile) []*utils.Segment {
	if s.Config.Filter == "" && s.Config.Species == "" && s.Config.Certainty < 0 {
		return df.Segments
	}
```

Deletion in tools/calls_classify.go at line 183 [7.20592]

B:BD[7.23193] → [7.23193:23259]

B:BD[7.23259] → [17.337:373]

∅:D[17.373] → [7.23302:23365]

B:BD[7.23302] → [7.23302:23365]

B:BD[7.23365] → [17.374:542]

B:BD[17.542] → [2.6199:6307]

∅:D[18.3167] → [17.858:861]

∅:D[2.6307] → [17.858:861]

B:BD[17.858] → [17.858:861]

	var filtered []*utils.Segment
	for _, seg := range df.Segments {
		if s.segmentMatchesFilters(seg) {
			filtered = append(filtered, seg)
		}
	}
	return filtered
}
// segmentMatchesFilters returns true if the segment has any label matching all active filters
func (s *ClassifyState) segmentMatchesFilters(seg *utils.Segment) bool {
	return seg.SegmentMatchesFilters(s.Config.Filter, s.Config.Species, s.Config.CallType, s.Config.Certainty)
}

Replacement in tools/calls_classify.go at line 186 [7.20592]

B:BD[7.23473] → [7.23473:23549]

	for _, df := range s.DataFiles {
		total += len(s.getFilteredSegments(df))

[7.23473]

[7.23549]

	for _, segs := range s.filteredSegs {
		total += len(segs)

Replacement in tools/calls_classify.go at line 195 [7.20592]

B:BD[7.23689] → [7.23689:23759]

	for i, df := range s.DataFiles {
		segs := s.getFilteredSegments(df)

[7.23689]

[7.23759]

	for i, segs := range s.filteredSegs {

Replacement in tools/calls_classify.go at line 209 [7.20592]
B:BD[7.24015] → [7.24015:24054]
```
	df := s.CurrentFile()
	if df == nil {
```
[7.24015]
[7.24054]
```
	if s.FileIdx >= len(s.filteredSegs) {
```
Replacement in tools/calls_classify.go at line 213 [7.20592]
B:BD[7.24073] → [7.24073:24108]
```
	segs := s.getFilteredSegments(df)
```
[7.24073]
[7.24108]
```
	segs := s.filteredSegs[s.FileIdx]
```
Replacement in tools/calls_classify.go at line 239 [7.20592]
B:BD[7.24538] → [7.24538:24598]
```
		df := s.CurrentFile()
		segs := s.getFilteredSegments(df)
```
[7.24538]
[19.1983]
```
		segs := s.filteredSegs[s.FileIdx]
```

Replacement in tools/calls_classify.go at line 495 [7.20592]

B:BD[20.3561] → [20.3561:3630]

			df := s.DataFiles[s.FileIdx]
			segs := s.getFilteredSegments(df)

[20.3561]

[20.3630]

			segs := s.filteredSegs[s.FileIdx]

Replacement in tools/calls_classify.go at line 514 [7.20592]
B:BD[20.4081] → [20.4081:4120]
```
	df := s.CurrentFile()
	if df == nil {
```
[20.4081]
[20.4120]
```
	if s.FileIdx >= len(s.filteredSegs) {
```
Replacement in tools/calls_classify.go at line 518 [7.20592]
B:BD[20.4139] → [20.4139:4174]
```
	segs := s.getFilteredSegments(df)
```
[20.4139]
[20.4174]
```
	segs := s.filteredSegs[s.FileIdx]
```
Replacement in tools/calls_classify.go at line 544 [7.20592]
B:BD[20.4624] → [20.4624:4684]
```
		df := s.CurrentFile()
		segs := s.getFilteredSegments(df)
```
[20.4624]
[20.4684]
```
		segs := s.filteredSegs[s.FileIdx]
```

Insertion in cmd/calls_classify.go at line 32 [7.28389]

[21.1339]

	fmt.Fprintf(os.Stderr, "  --goto <filename>     Start at this .data file (basename match, optional)\n")

Replacement in cmd/calls_classify.go at line 51 [7.28389]

B:BD[7.28612] → [17.1405:1457]

	var folder, file, filter, reviewer, species string

[7.28612]

[22.2815]

	var folder, file, filter, reviewer, species, gotoFile string

Insertion in cmd/calls_classify.go at line 141 [7.28389]

[22.2887]


		case "--goto":
			if i+1 >= len(args) {
				fmt.Fprintf(os.Stderr, "Error: --goto requires a value\n")
				os.Exit(1)
			}
			gotoFile = args[i+1]
			i += 2

Insertion in cmd/calls_classify.go at line 208 [7.28389]
[2.7828]
[14.1397]
```
		Goto:      gotoFile,
```

Insertion in CHANGELOG.md at line 4 [23.1]

[23.81]

[4.13749]


## [2026-04-05] Simplify calls classify TUI
**Static segment list:** Filtered segments are now computed once at startup and cached.
Reclassifying a segment no longer removes it from the navigation list mid-session.
This fixes instability/crashes when working fast with `--species` or other filters.
**Replace goto dialog with `--goto` flag:**
- Removed ctrl+g goto dialog from TUI (and all supporting code)
- Added `--goto <filename>` CLI flag that opens on the first matching segment in the named file
- Removed `GotoFile()` and `TotalFiles()` methods from `ClassifyState`
**Internal:** Added `NewClassifyState()` constructor for tests. All `getFilteredSegments()` calls
replaced with pre-computed `filteredSegs` cache parallel to `DataFiles`.
**Files changed:**
- `tools/calls_classify.go` — cached segments, `--goto` support, removed dynamic filtering
- `tui/classify.go` — removed goto dialog (model fields, handler, renderer, keybind)
- `cmd/calls_classify.go` — added `--goto` flag parsing
- `tools/calls_classify_*_test.go` — updated to use `NewClassifyState()`