expected := "\x1b[2J\x1b[H"
	if buf.String() != expected {
		t.Errorf("got %q, want %q", buf.String(), expected)

	if buf.String() != "" {
		t.Errorf("expected no output for sixel clear, got %q", buf.String())

// For kitty, deletes all image placements. For sixel, erases the display
// since sixel images are inline pixel data that persists through text redraws.

// For kitty, deletes all image placements. For sixel, no-op (inline text).

		// Erase display + cursor home to clear sixel pixel data
		_, err := io.WriteString(w, "\x1b[2J\x1b[H")
		return err

		return nil

	"os"

	if m.protocol() == utils.ProtocolSixel {
		return sixelImageCmd(m.state)
	}

// segmentChangeCmd returns the appropriate command after a segment change.
// For sixel: sequence clear screen then write sixel (runs after View renders).
// For kitty: just clear screen (kitty images are managed in View).
func (m Model) segmentChangeCmd() tea.Cmd {
	if m.protocol() == utils.ProtocolSixel {
		return tea.Sequence(tea.ClearScreen, sixelImageCmd(m.state))
	}
	return tea.ClearScreen
}

		return m, tea.ClearScreen

		return m, m.segmentChangeCmd()

		return m, tea.ClearScreen

		return m, m.segmentChangeCmd()

				return m, tea.ClearScreen

				return m, m.segmentChangeCmd()

		utils.ClearImages(&b, m.protocol())

		if m.protocol() == utils.ProtocolKitty {
			utils.ClearKittyImages(&b)
		}

	// Clear any images from previous render
	utils.ClearImages(&b, m.protocol())

	// Clear kitty images from previous render (sixel is handled via commands)
	if m.protocol() == utils.ProtocolKitty {
		utils.ClearKittyImages(&b)
	}

	// Spectrogram image at bottom
	m.renderSpectrogram(&b, df.FilePath, seg)

	// Spectrogram image at bottom (kitty only — sixel is written via command)
	if m.protocol() == utils.ProtocolKitty {
		m.renderSpectrogram(&b, df.FilePath, seg)
	}

// renderSpectrogram generates and outputs a spectrogram image

// renderSpectrogram generates and outputs a spectrogram image via kitty protocol

	// Derive WAV path and load samples

	img := generateSpectrogramImage(m.state, dataPath, seg)
	if img == nil {
		b.WriteString("[error generating spectrogram]")
		return
	}
	utils.WriteKittyImage(img, b)
}
// generateSpectrogramImage creates a resized spectrogram image from a segment.
func generateSpectrogramImage(state *tools.ClassifyState, dataPath string, seg *utils.Segment) image.Image {

		b.WriteString("[error loading WAV]")
		return

		return nil

	// Extract segment samples

		b.WriteString("[no samples]")
		return

		return nil

	// Generate spectrogram

		b.WriteString("[error generating spectrogram]")
		return

		return nil

	// Create image

	if m.state.Config.Color {

	if state.Config.Color {

		b.WriteString("[error creating image]")
		return

		return nil

	imgSize := m.state.Config.ImageSize

	imgSize := state.Config.ImageSize

	resized := utils.ResizeImage(img, imgSize, imgSize)

	return utils.ResizeImage(img, imgSize, imgSize)
}
// sixelImageCmd returns a tea.Cmd that generates and writes a sixel image
// directly to the terminal, bypassing BubbleTea's renderer.
func sixelImageCmd(state *tools.ClassifyState) tea.Cmd {
	return func() tea.Msg {
		df := state.CurrentFile()
		seg := state.CurrentSegment()
		if df == nil || seg == nil {
			return nil
		}

	// Output via terminal graphics protocol (images cleared at start of View)
	utils.WriteImage(resized, b, m.protocol())

		img := generateSpectrogramImage(state, df.FilePath, seg)
		if img == nil {
			return nil
		}
		fmt.Fprint(os.Stdout, "\r\n\r\n")
		utils.WriteSixelImage(img, os.Stdout)
		return nil
	}