}
}
func TestLabelComment(t *testing.T) {
	// Test parsing comment from .data file
	content := `[
		{"Operator": "Test", "Duration": 60.0},
		[10.0, 20.0, 0, 0, [{"species": "Kiwi", "certainty": 100, "filter": "M", "comment": "Good call"}]]
	]`
	tmpfile, err := os.CreateTemp("", "test*.data")
	if err != nil {
		t.Fatal(err)
	}
	defer os.Remove(tmpfile.Name())
	if _, err := tmpfile.Write([]byte(content)); err != nil {
		t.Fatal(err)
	}
	tmpfile.Close()
	df, err := ParseDataFile(tmpfile.Name())
	if err != nil {
		t.Fatal(err)
	}
	if df.Segments[0].Labels[0].Comment != "Good call" {
		t.Errorf("expected Comment='Good call', got '%s'", df.Segments[0].Labels[0].Comment)
	}
	// Test writing comment
	df.Segments[0].Labels[0].Comment = "Updated comment"
	tmpfile2, err := os.CreateTemp("", "test2*.data")
	if err != nil {
		t.Fatal(err)
	}
	tmpfile2.Close()
	defer os.Remove(tmpfile2.Name())
	if err := df.Write(tmpfile2.Name()); err != nil {
		t.Fatal(err)

	// Re-parse and verify
	df2, err := ParseDataFile(tmpfile2.Name())
	if err != nil {
		t.Fatal(err)
	}
	if df2.Segments[0].Labels[0].Comment != "Updated comment" {
		t.Errorf("expected Comment='Updated comment', got '%s'", df2.Segments[0].Labels[0].Comment)
	}

	Comment   string         // user comment (max 140 chars, ASCII only)

	}
	if v, ok := obj["comment"].(string); ok {
		label.Comment = v
		delete(obj, "comment")

			}
			if label.Comment != "" {
				l["comment"] = label.Comment

	commentBoxStyle = lipgloss.NewStyle().
				Border(lipgloss.RoundedBorder()).
				BorderForeground(lipgloss.Color("62")).
				Padding(0, 1)
	commentInputStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("15"))
	commentHelpStyle = lipgloss.NewStyle().
				Foreground(lipgloss.Color("241"))

	// Comment dialog state
	commentMode bool   // true when comment dialog is open
	commentText string // current input text

	// If in comment mode, route to comment handler
	if m.commentMode {
		return m.handleCommentKey(msg)
	}

	}
	// Check for Space key (open comment dialog)
	if key.Code == tea.KeySpace {
		m.commentText = m.state.GetCurrentComment()
		m.commentMode = true
		return m, nil

		}
		return m, nil
	}
}
// handleCommentKey handles key presses in comment mode
func (m Model) handleCommentKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) {
	key := msg.Key()
	// Enter: save comment
	if key.Code == tea.KeyEnter {
		m.state.SetComment(m.commentText)
		if err := m.state.Save(); err != nil {
			m.err = err.Error()
		}
		m.commentMode = false
		return m, nil
	}
	// Escape: cancel
	if key.Code == tea.KeyEscape || key.Code == tea.KeyEsc {
		m.commentMode = false
		return m, nil
	}
	// Handle via string representation
	switch msg.String() {
	case "backspace":
		if len(m.commentText) > 0 {
			m.commentText = m.commentText[:len(m.commentText)-1]
		}
		return m, nil
	case "ctrl+u":
		m.commentText = ""
		return m, nil
	}
	// Printable ASCII character
	s := msg.String()
	if len(s) == 1 && s[0] >= 32 && s[0] <= 126 {
		if len(m.commentText) < 140 {
			m.commentText += s

	return m, nil

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

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

	// Comment dialog (when active)
	if m.commentMode {
		m.renderCommentDialog(&b)
		return tea.NewView(b.String())
	}

// renderCommentDialog renders the comment input dialog
func (m Model) renderCommentDialog(b *strings.Builder) {
	// Build dialog content
	inputLine := m.commentText + "█" // cursor
	charCount := fmt.Sprintf("%d/140", len(m.commentText))
	helpLine := "[enter]save  [esc]cancel  [ctrl+u]clear"
	// Render box
	content := fmt.Sprintf("Comment:\n%s\n%s\n%s", inputLine, charCount, helpLine)
	b.WriteString(commentBoxStyle.Render(content))
}

	Comment  string // optional comment to attach

// SetComment sets the comment on the current segment's filter label.
// Returns the previous comment (for undo) or empty string if none.
func (s *ClassifyState) SetComment(comment string) string {
	seg := s.CurrentSegment()
	if seg == nil {
		return ""
	}
	df := s.CurrentFile()
	if df == nil {
		return ""
	}
	// Set reviewer
	df.Meta.Reviewer = s.Config.Reviewer
	// Get labels matching filter
	filterLabels := seg.GetFilterLabels(s.Config.Filter)
	var oldComment string
	if len(filterLabels) == 0 {
		// No matching labels, add new one with comment
		label := &utils.Label{
			Species:   "Don't Know",
			Certainty: 0,
			Filter:    s.Config.Filter,
			Comment:   comment,
		}
		seg.Labels = append(seg.Labels, label)
	} else {
		// Set comment on first matching label
		oldComment = filterLabels[0].Comment
		filterLabels[0].Comment = comment
	}
	s.Dirty = true
	return oldComment
}
// GetCurrentComment returns the comment on the current segment's filter label.
func (s *ClassifyState) GetCurrentComment() string {
	seg := s.CurrentSegment()
	if seg == nil {
		return ""
	}
	filterLabels := seg.GetFilterLabels(s.Config.Filter)
	if len(filterLabels) == 0 {
		return ""
	}
	return filterLabels[0].Comment
}

		if l.Comment != "" {
			part += fmt.Sprintf(" \"%s\"", l.Comment)
		}

## [2026-03-07] Comment Feature in Classify TUI
**New feature:** Press spacebar in the classify TUI to add/edit comments on labels.

**Changes:**
- `utils/data_file.go` — Added `Comment` field to `Label` struct, parse/write handling
- `tools/calls_classify.go` — Added `SetComment()` and `GetCurrentComment()` methods, `Comment` field in `BindingResult`
- `tui/classify.go` — Added `commentMode`/`commentText` state, spacebar opens dialog, text input handling, dialog rendering
**AviaNZ spec compliance:** The spec allows "any additional attributes defined for this call" as key-value pairs. Comments are stored as `"comment": "text"` in the label object.
**Usage:**
- `[space]` — Open comment dialog (pre-fills existing comment)
- Type comment (max 140 chars, ASCII only)
- `[enter]` — Save comment
- `[esc]` — Cancel (discard changes)
- `[backspace]` — Delete last character
- `[ctrl+u]` — Clear all
**Help text:** `[esc]quit [,]prev [.]next [space]comment [enter]play [shift+enter]½speed`