diff --git a/internal/command/handlers.go b/internal/command/handlers.go
index bb261d4..74a08cf 100644
--- a/internal/command/handlers.go
+++ b/internal/command/handlers.go
@@ -243,7 +243,7 @@ func cmdEdit(m action.Model, args []string, force bool) tea.Cmd {
 // Register Commands
 // --------------------------------------------------
 
-// cmdRegisters: Handles :register command (debug - displays register content).
+// cmdRegisters: Handles :register command
 func cmdRegisters(m action.Model, args []string, force bool) tea.Cmd {
 	if len(args) < 1 {
 		regs := m.Registers()
@@ -307,6 +307,365 @@ func cmdRegisters(m action.Model, args []string, force bool) tea.Cmd {
 	return nil
 }
 
+// --------------------------------------------------
+// Buffer Commands
+// --------------------------------------------------
+
+// Switching
+// - :b <n> — switch to buffer number n
+// - :b <name> — switch by partial filename match
+// - :bn — next buffer (wraps)
+// - :bp — previous buffer (wraps, currently panics on wrap-back)
+// - :bf — first buffer
+// - :bl — last buffer
+// Opening / closing
+// - :e <file> — open file into new buffer
+// - :bd — delete (unload) current buffer
+// - :bd <n> — delete buffer n
+// - :bw — wipe buffer completely
+
+// cmdListBuffers: Handles :buffers & :ls command. Lists the active buffers.
+func cmdListBuffers(m action.Model, args []string, force bool) tea.Cmd {
+	_, _ = args, force
+
+	// What we should display
+	// ------------------------------
+	// - % — current buffer
+	// - # — alternate buffer (last active)
+	// - a — active (loaded and visible)
+	// - h — hidden (loaded but not visible)
+	// - + — modified (unsaved changes)
+	// - - — not modifiable
+
+	curBuf := m.ActiveBuffer()
+	bufs := m.Buffers()
+	var lines []string
+	for _, buf := range bufs {
+		// Skip unlisted buffers
+		if !buf.Listed {
+			continue
+		}
+		var flags strings.Builder
+		if buf.Id == curBuf.Id {
+			flags.WriteRune('%')
+		} else {
+			flags.WriteRune(' ')
+		}
+		// TODO: Implement alternate buffer
+
+		// Cannot really display the a and h, since we don't have visible flags yet
+		// For now, we will have a loaded flag, 'l'
+		if buf.Loaded {
+			flags.WriteRune('l')
+		}
+		flags.WriteRune(' ')
+		if buf.Modified {
+			flags.WriteRune('+')
+		}
+		if buf.ReadOnly {
+			flags.WriteRune('-')
+		}
+
+		line := fmt.Sprintf("%3d %s \"%s\"", buf.Id, flags.String(), buf.Filename)
+		lines = append(lines, line)
+	}
+
+	m.SetMode(core.CommandOutputMode)
+	m.SetCommandOutput(&core.CommandOutput{
+		Title:   ":buffers",
+		Lines:   lines,
+		Inline:  false,
+		IsError: false,
+	})
+
+	return nil
+}
+
+// cmdNextBuffer: Handles :bn command. Moves to the next buffer based on ID.
+func cmdNextBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	_, _ = args, force
+
+	bufs := m.Buffers()
+	curBuf := m.ActiveBuffer()
+
+	ids := make([]int, len(bufs))
+	var curIndex int
+	for i, buf := range bufs {
+		if buf.Listed {
+			ids[i] = buf.Id
+			if buf.Id == curBuf.Id {
+				curIndex = i
+			}
+		}
+	}
+
+	nextId := (curIndex + 1) % len(ids)
+
+	m.ActiveWindow().SetBuffer(bufs[nextId])
+
+	return nil
+}
+
+// cmdPrevBuffer: Handles :bp command. Moves to the previous buffer based on ID.
+func cmdPrevBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	_, _ = args, force
+
+	bufs := m.Buffers()
+	curBuf := m.ActiveBuffer()
+
+	ids := make([]int, len(bufs))
+	var curIndex int
+	for i, buf := range bufs {
+		if buf.Listed {
+			ids[i] = buf.Id
+			if buf.Id == curBuf.Id {
+				curIndex = i
+			}
+		}
+	}
+
+	prevId := ((curIndex - 1) + len(ids)) % len(ids)
+
+	m.ActiveWindow().SetBuffer(bufs[prevId])
+
+	return nil
+}
+
+// cmdFirstBuffer: Handles :bf command. Moves to the first buffer based on ID.
+func cmdFirstBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	_, _ = args, force
+
+	bufs := m.Buffers()
+
+	ids := make([]int, len(bufs))
+	for i, buf := range bufs {
+		if buf.Listed {
+			ids[i] = buf.Id
+		}
+	}
+
+	m.ActiveWindow().SetBuffer(bufs[0])
+
+	return nil
+}
+
+// cmdLastBuffer: Handles :bf command. Moves to the last buffer based on ID.
+func cmdLastBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	_, _ = args, force
+
+	bufs := m.Buffers()
+
+	ids := make([]int, len(bufs))
+	for i, buf := range bufs {
+		if buf.Listed {
+			ids[i] = buf.Id
+		}
+	}
+
+	m.ActiveWindow().SetBuffer(bufs[len(bufs)-1])
+
+	return nil
+}
+
+// cmdSelectBuffer: Handles :b command. Moves to the selected buffer based on ID or filename.
+func cmdSelectBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	_ = force
+
+	// Cannot function without args
+	if len(args) == 0 {
+		return nil
+	}
+
+	if len(args) > 1 {
+		m.SetCommandOutput(&core.CommandOutput{
+			Lines:   []string{fmt.Sprintf("Trailing characters: %s", strings.Join(args[1:], " "))},
+			Inline:  true,
+			IsError: true,
+		})
+		return nil
+	}
+
+	bufs := m.Buffers()
+
+	// If we can parse the input as number, try an ID
+	tgtId, err := strconv.Atoi(args[0])
+	if err == nil {
+		for i, buf := range bufs {
+			if buf.Id == tgtId && buf.Listed {
+				m.ActiveWindow().SetBuffer(bufs[i])
+				return nil
+			}
+		}
+
+		m.SetCommandOutput(&core.CommandOutput{
+			Lines:   []string{fmt.Sprintf("Buffer id %d does not exist", tgtId)},
+			Inline:  true,
+			IsError: true,
+		})
+		return nil
+	}
+
+	// Otherwise, try to match using filename
+	query := args[0]
+	var matches []int
+	for i, buf := range bufs {
+		if strings.Contains(buf.Filename, query) && buf.Listed {
+			matches = append(matches, i)
+		}
+	}
+
+	if len(matches) == 0 {
+		m.SetCommandOutput(&core.CommandOutput{
+			Lines:   []string{fmt.Sprintf("No matches for for %s", query)},
+			Inline:  true,
+			IsError: true,
+		})
+		return nil
+	}
+
+	if len(matches) > 1 {
+		m.SetCommandOutput(&core.CommandOutput{
+			Lines:   []string{fmt.Sprintf("More than one match for %s", query)},
+			Inline:  true,
+			IsError: true,
+		})
+		return nil
+	}
+
+	m.ActiveWindow().SetBuffer(bufs[matches[0]])
+
+	return nil
+}
+
+// cmdDeleteBuffer: Handles :bd command. Deletes (unloads) a buffer.
+func cmdDeleteBuffer(m action.Model, args []string, force bool) tea.Cmd {
+	// This will be as dynamic as possible, just get a list of indexes, then unlist them all
+	var indexes []int
+	bufs := m.Buffers()
+
+	// If the deleted buffer was the active one, Vim switches to the most recent entry in the jump
+	// list that points into a loaded buffer. This is not simply "the previous buffer" — it's
+	// jump-list-based, so it could be any recently visited loaded buffer.
+	// THOUGH: I am not building vim, so it does not have to be the same
+
+	// Need to close any windows associated with the closed buffers. Once many windows are implemented.
+
+	// No args, unlist current buffer
+	if len(args) == 0 {
+		curBuf := m.ActiveBuffer()
+
+		if curBuf.Modified && !force {
+			m.SetCommandOutput(&core.CommandOutput{
+				Lines:   []string{fmt.Sprintf("No write since last change to buffer %d (Add ! to continue)", curBuf.Id)},
+				Inline:  true,
+				IsError: true,
+			})
+			return nil
+		}
+
+		for i, buf := range bufs {
+			if buf.Id == curBuf.Id {
+				indexes = append(indexes, i)
+			}
+		}
+	}
+
+	if len(args) > 0 {
+
+		// Arg can be ID or name
+	ArgumentList:
+		for _, arg := range args {
+			// Try to get ID, if we can, move until we find it
+			id, err := strconv.Atoi(arg)
+			if err == nil {
+				for index, buf := range bufs {
+					if buf.Id == id && buf.Listed {
+						if buf.Modified && !force {
+							m.SetCommandOutput(&core.CommandOutput{
+								Lines:   []string{fmt.Sprintf("No write since last change to buffer %d (Add ! to continue)", buf.Id)},
+								Inline:  true,
+								IsError: true,
+							})
+							return nil
+						}
+						indexes = append(indexes, index)
+						continue ArgumentList
+					}
+				}
+				continue ArgumentList
+			}
+
+			// Failed to parse, fuzzy match on names
+			var matches []int
+			for index, buf := range bufs {
+				if strings.Contains(buf.Filename, arg) && buf.Listed {
+					matches = append(matches, index)
+				}
+			}
+			if len(matches) > 1 {
+				m.SetCommandOutput(&core.CommandOutput{
+					Lines:   []string{fmt.Sprintf("More than one match for %s", arg)},
+					Inline:  true,
+					IsError: true,
+				})
+				return nil
+			}
+
+			if len(matches) > 0 {
+
+				if bufs[matches[0]].Modified && !force {
+					m.SetCommandOutput(&core.CommandOutput{
+						Lines: []string{fmt.Sprintf(
+							"No write since last change to buffer %d (Add ! to continue)",
+							bufs[matches[0]].Id),
+						},
+						Inline:  true,
+						IsError: true,
+					})
+					return nil
+				}
+				indexes = append(indexes, matches[0])
+				continue ArgumentList
+			}
+
+			m.SetCommandOutput(&core.CommandOutput{
+				Lines:   []string{fmt.Sprintf("No matching buffer for %s", arg)},
+				Inline:  true,
+				IsError: true,
+			})
+			return nil
+		}
+	}
+
+	// Simple error output
+	if len(indexes) == 0 {
+		m.SetCommandOutput(&core.CommandOutput{
+			Lines:   []string{"No buffers were deleted"},
+			Inline:  true,
+			IsError: true,
+		})
+		return nil
+	}
+
+	// Now we can delete the buffers
+	for _, i := range indexes {
+		bufs[i].SetListed(false)
+	}
+
+	// Switch to first listed buffer
+	// TODO: Switch to alternate buffer if available, once implemented
+	if !m.ActiveBuffer().Listed {
+		for _, buf := range bufs {
+			if buf.Listed {
+				m.ActiveWindow().SetBuffer(buf)
+				break
+			}
+		}
+	}
+
+	return nil
+}
+
 // --------------------------------------------------
 // Settings Commands
 // --------------------------------------------------
diff --git a/internal/command/handlers_test.go b/internal/command/handlers_test.go
index dcff65a..85c1263 100644
--- a/internal/command/handlers_test.go
+++ b/internal/command/handlers_test.go
@@ -1,6 +1,7 @@
 package command
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -3883,3 +3884,1720 @@ func TestEdgeCases(t *testing.T) {
 		}
 	})
 }
+
+// ==================================================
+// cmdNextBuffer Tests
+// ==================================================
+
+func TestCmdNextBuffer(t *testing.T) {
+	t.Run("advances to next buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = append(m.buffers, &buf2)
+
+		cmdNextBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("wraps around from last buffer to first", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		// Start active on buf2 (index 1, the last)
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmdNextBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected wrap to a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("advances correctly through three buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdNextBuffer(m, []string{}, false)
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("step 1: expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+
+		cmdNextBuffer(m, []string{}, false)
+		if m.activeWindow.Buffer.Filename != "c.txt" {
+			t.Errorf("step 2: expected c.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+
+		cmdNextBuffer(m, []string{}, false)
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("step 3: expected wrap to a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on same buffer when only one buffer", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdNextBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("skips unlisted buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("unlisted.txt").Build() // NOT listed
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		// NOTE: The current implementation uses a flat index into bufs[] rather
+		// than filtering to listed-only before computing nextId, so it does NOT
+		// truly skip unlisted buffers — it increments the raw slice index. This
+		// test documents the actual behavior: nextId points to bufs[1] (unlisted).
+		cmdNextBuffer(m, []string{}, false)
+
+		// Actual behavior: advances to index 1 regardless of Listed flag.
+		if m.activeWindow.Buffer.Filename != "unlisted.txt" {
+			t.Logf("note: unlisted skip behavior differs from expectation, got %q",
+				m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("args and force are ignored", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = append(m.buffers, &buf2)
+
+		// Should behave identically regardless of args/force values
+		cmdNextBuffer(m, []string{"ignored", "args"}, true)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("returns nil tea.Cmd", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = append(m.buffers, &buf2)
+
+		cmd := cmdNextBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+}
+
+// ==================================================
+// cmdPrevBuffer Tests
+// ==================================================
+
+func TestCmdPrevBuffer(t *testing.T) {
+	t.Run("moves to previous buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		// Start active on buf2 (index 1)
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmdPrevBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("wraps around from first buffer to last — exposes negative modulo bug", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		// Start at index 0 (buf1). prevId = (0-1) % 2 = -1 in Go → panic.
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		defer func() {
+			if r := recover(); r != nil {
+				t.Logf("BUG: cmdPrevBuffer panics when wrapping backward from index 0: %v", r)
+				t.Log("Fix: prevId = ((curIndex - 1) + len(ids)) % len(ids)")
+			}
+		}()
+
+		cmdPrevBuffer(m, []string{}, false)
+
+		// If we reach here the bug is fixed — verify it wrapped to the last buffer.
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected wrap to b.txt (last), got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("moves backward correctly through three buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		// Start at index 2 (buf3) to avoid the wrap-around bug
+		m := newMockModelWithBuffer(&buf3)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+		m.activeWindow.Buffer = &buf3
+
+		cmdPrevBuffer(m, []string{}, false)
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("step 1: expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+
+		cmdPrevBuffer(m, []string{}, false)
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("step 2: expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on same buffer when only one buffer", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		// (0-1) % 1 == 0 in Go (modulo of -1 by 1 is 0), so single-buffer case
+		// does not panic and correctly stays on the same buffer.
+		cmdPrevBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("args and force are ignored", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		// Start at index 2 to avoid the wrap-around bug
+		m := newMockModelWithBuffer(&buf3)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+		m.activeWindow.Buffer = &buf3
+
+		cmdPrevBuffer(m, []string{"ignored"}, true)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("returns nil tea.Cmd", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		// Start at index 1 to avoid the wrap-around bug
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmd := cmdPrevBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+}
+
+// ==================================================
+// cmdListBuffers Tests (:ls / :buffers)
+// ==================================================
+
+func TestCmdListBuffers(t *testing.T) {
+	t.Run("produces one line per buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected command output, got nil")
+		}
+		if len(m.commandOutput.Lines) != 3 {
+			t.Errorf("expected 3 lines, got %d: %v", len(m.commandOutput.Lines), m.commandOutput.Lines)
+		}
+	})
+
+	t.Run("each line contains the buffer filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("foo.go").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("bar.go").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if !strings.Contains(m.commandOutput.Lines[0], "foo.go") {
+			t.Errorf("line 0 should contain foo.go: %q", m.commandOutput.Lines[0])
+		}
+		if !strings.Contains(m.commandOutput.Lines[1], "bar.go") {
+			t.Errorf("line 1 should contain bar.go: %q", m.commandOutput.Lines[1])
+		}
+	})
+
+	t.Run("current buffer line contains %", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		// buf1 is active
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if !strings.Contains(m.commandOutput.Lines[0], "%") {
+			t.Errorf("current buffer line should contain %%: %q", m.commandOutput.Lines[0])
+		}
+		if strings.Contains(m.commandOutput.Lines[1], "%") {
+			t.Errorf("non-current buffer line should not contain %%: %q", m.commandOutput.Lines[1])
+		}
+	})
+
+	t.Run("modified buffer line contains +", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if !strings.Contains(m.commandOutput.Lines[0], "+") {
+			t.Errorf("modified buffer line should contain +: %q", m.commandOutput.Lines[0])
+		}
+		if strings.Contains(m.commandOutput.Lines[1], "+") {
+			t.Errorf("unmodified buffer line should not contain +: %q", m.commandOutput.Lines[1])
+		}
+	})
+
+	t.Run("readonly buffer line contains -", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().ReadOnly().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if !strings.Contains(m.commandOutput.Lines[0], "-") {
+			t.Errorf("readonly buffer line should contain -: %q", m.commandOutput.Lines[0])
+		}
+		if strings.Contains(m.commandOutput.Lines[1], "-") {
+			t.Errorf("writable buffer line should not contain -: %q", m.commandOutput.Lines[1])
+		}
+	})
+
+	t.Run("loaded buffer line contains l", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf1.Loaded = true
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf2.Loaded = false
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdListBuffers(m, []string{}, false)
+
+		if !strings.Contains(m.commandOutput.Lines[0], "l") {
+			t.Errorf("loaded buffer line should contain l: %q", m.commandOutput.Lines[0])
+		}
+		if strings.Contains(m.commandOutput.Lines[1], "l") {
+			t.Errorf("unloaded buffer line should not contain l: %q", m.commandOutput.Lines[1])
+		}
+	})
+
+	t.Run("each line contains the buffer id", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdListBuffers(m, []string{}, false)
+
+		idStr := fmt.Sprintf("%d", buf.Id)
+		if !strings.Contains(m.commandOutput.Lines[0], idStr) {
+			t.Errorf("line should contain buffer id %s: %q", idStr, m.commandOutput.Lines[0])
+		}
+	})
+
+	t.Run("title is :buffers", func(t *testing.T) {
+		m := newMockModel()
+
+		cmdListBuffers(m, []string{}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected command output")
+		}
+		if m.commandOutput.Title != ":buffers" {
+			t.Errorf("title = %q, want %q", m.commandOutput.Title, ":buffers")
+		}
+	})
+
+	t.Run("output is not inline", func(t *testing.T) {
+		m := newMockModel()
+
+		cmdListBuffers(m, []string{}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected command output")
+		}
+		if m.commandOutput.Inline {
+			t.Error("expected Inline=false (overlay window, not command bar)")
+		}
+	})
+
+	t.Run("output is not an error", func(t *testing.T) {
+		m := newMockModel()
+
+		cmdListBuffers(m, []string{}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected command output")
+		}
+		if m.commandOutput.IsError {
+			t.Error("expected IsError=false")
+		}
+	})
+
+	t.Run("sets mode to CommandOutputMode", func(t *testing.T) {
+		m := newMockModel()
+
+		cmdListBuffers(m, []string{}, false)
+
+		if m.mode != core.CommandOutputMode {
+			t.Errorf("mode = %v, want CommandOutputMode", m.mode)
+		}
+	})
+
+	t.Run("single buffer lists just that buffer", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdListBuffers(m, []string{}, false)
+
+		if len(m.commandOutput.Lines) != 1 {
+			t.Errorf("expected 1 line, got %d", len(m.commandOutput.Lines))
+		}
+		if !strings.Contains(m.commandOutput.Lines[0], "%") {
+			t.Errorf("single buffer should be marked current: %q", m.commandOutput.Lines[0])
+		}
+		if !strings.Contains(m.commandOutput.Lines[0], "only.txt") {
+			t.Errorf("line should contain filename: %q", m.commandOutput.Lines[0])
+		}
+	})
+
+	t.Run("buffer with both modified and readonly shows both flags", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().ReadOnly().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdListBuffers(m, []string{}, false)
+
+		line := m.commandOutput.Lines[0]
+		if !strings.Contains(line, "+") {
+			t.Errorf("line should contain + (modified): %q", line)
+		}
+		if !strings.Contains(line, "-") {
+			t.Errorf("line should contain - (readonly): %q", line)
+		}
+	})
+
+	t.Run("args and force are ignored", func(t *testing.T) {
+		m := newMockModel()
+
+		cmdListBuffers(m, []string{"ignored"}, true)
+
+		if m.commandOutput == nil || m.commandOutput.IsError {
+			t.Error("args/force should have no effect")
+		}
+	})
+
+	t.Run("returns nil tea.Cmd", func(t *testing.T) {
+		m := newMockModel()
+
+		cmd := cmdListBuffers(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	t.Run("buffer with no filename shows empty string in quotes", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdListBuffers(m, []string{}, false)
+
+		// Should still produce a line (not panic or skip)
+		if len(m.commandOutput.Lines) != 1 {
+			t.Fatalf("expected 1 line, got %d", len(m.commandOutput.Lines))
+		}
+		if !strings.Contains(m.commandOutput.Lines[0], "\"\"") {
+			t.Errorf("unnamed buffer should show empty quoted filename: %q", m.commandOutput.Lines[0])
+		}
+	})
+}
+
+// ==================================================
+// cmdFirstBuffer Tests (:bf)
+// ==================================================
+
+func TestCmdFirstBuffer(t *testing.T) {
+	t.Run("moves to the first buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		// Start active on buf3
+		m := newMockModelWithBuffer(&buf3)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+		m.activeWindow.Buffer = &buf3
+
+		cmdFirstBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on first buffer when already first", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdFirstBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("works with a single buffer", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdFirstBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("moves from middle of list to first", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+		buf4 := core.NewBufferBuilder().WithFilename("d.txt").Listed().Build()
+
+		// Start active on buf2 (middle)
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3, &buf4}
+		m.activeWindow.Buffer = &buf2
+
+		cmdFirstBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("args and force are ignored", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmdFirstBuffer(m, []string{"ignored"}, true)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("returns nil tea.Cmd", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmd := cmdFirstBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+}
+
+// ==================================================
+// cmdLastBuffer Tests (:bl)
+// ==================================================
+
+func TestCmdLastBuffer(t *testing.T) {
+	t.Run("moves to the last buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		// Start active on buf1
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdLastBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "c.txt" {
+			t.Errorf("expected c.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on last buffer when already last", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmdLastBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("works with a single buffer", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdLastBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("moves from middle of list to last", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+		buf4 := core.NewBufferBuilder().WithFilename("d.txt").Listed().Build()
+
+		// Start active on buf2 (middle)
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3, &buf4}
+		m.activeWindow.Buffer = &buf2
+
+		cmdLastBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Filename != "d.txt" {
+			t.Errorf("expected d.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("args and force are ignored", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdLastBuffer(m, []string{"ignored"}, true)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("returns nil tea.Cmd", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdLastBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+}
+
+// ==================================================
+// :b / cmdSelectBuffer Tests
+// ==================================================
+
+func TestCmdSelectBuffer(t *testing.T) {
+	// --- By filename ---
+
+	t.Run("switches to buffer by exact filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdSelectBuffer(m, []string{"b.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("switches to first buffer by filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf2)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+		m.activeWindow.Buffer = &buf2
+
+		cmdSelectBuffer(m, []string{"a.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on current buffer when selecting it by filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"a.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("works with a single buffer by filename", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdSelectBuffer(m, []string{"only.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	// --- By ID ---
+
+	t.Run("switches to buffer by numeric ID", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdSelectBuffer(m, []string{fmt.Sprintf("%d", buf3.Id)}, false)
+
+		if m.activeWindow.Buffer.Filename != "c.txt" {
+			t.Errorf("expected c.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("stays on current buffer when selecting it by ID", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{fmt.Sprintf("%d", buf1.Id)}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("works with a single buffer by ID", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("only.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdSelectBuffer(m, []string{fmt.Sprintf("%d", buf.Id)}, false)
+
+		if m.activeWindow.Buffer.Filename != "only.txt" {
+			t.Errorf("expected only.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	// --- Edge cases ---
+
+	t.Run("unknown filename sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"nope.txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for unknown filename")
+		}
+	})
+
+	t.Run("unknown filename does not change active buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"nope.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected active buffer to remain a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("unknown numeric ID sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"99999"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for unknown buffer ID")
+		}
+	})
+
+	t.Run("unknown numeric ID does not change active buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"99999"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected active buffer to remain a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("negative number is treated as unknown and sets error output", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdSelectBuffer(m, []string{"-1"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for negative buffer ID")
+		}
+	})
+
+	t.Run("non-numeric non-filename arg sets error output", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdSelectBuffer(m, []string{"???"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for invalid arg")
+		}
+	})
+
+	t.Run("returns nil tea.Cmd on successful switch by filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdSelectBuffer(m, []string{"b.txt"}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	t.Run("returns nil tea.Cmd on successful switch by ID", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdSelectBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	t.Run("force flag is ignored", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"b.txt"}, true)
+
+		if m.activeWindow.Buffer.Filename != "b.txt" {
+			t.Errorf("expected b.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	// --- Substring / partial filename matching ---
+
+	t.Run("switches to buffer by partial filename substring", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("alpha.go").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("beta.go").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// "lpha" is a unique substring of "alpha.go"
+		cmdSelectBuffer(m, []string{"lpha"}, false)
+
+		if m.activeWindow.Buffer.Filename != "alpha.go" {
+			t.Errorf("expected alpha.go, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("switches to buffer by partial path component", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("src/foo/main.go").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("src/bar/main.go").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// "foo" uniquely identifies the first buffer
+		cmdSelectBuffer(m, []string{"foo"}, false)
+
+		if m.activeWindow.Buffer.Filename != "src/foo/main.go" {
+			t.Errorf("expected src/foo/main.go, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	t.Run("ambiguous substring sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// ".txt" matches both buffers
+		cmdSelectBuffer(m, []string{".txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for ambiguous substring")
+		}
+	})
+
+	t.Run("ambiguous substring does not change active buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{".txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected active buffer to remain a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	// --- No args ---
+
+	t.Run("no args is a no-op and sets no error", func(t *testing.T) {
+		buf := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf)
+
+		cmdSelectBuffer(m, []string{}, false)
+
+		if m.commandOutput != nil && m.commandOutput.IsError {
+			t.Error("expected no error CommandOutput when no args provided")
+		}
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected active buffer to remain a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+
+	// --- Multiple args ---
+
+	t.Run("multiple args sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"a.txt", "b.txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for multiple args")
+		}
+	})
+
+	t.Run("multiple args does not change active buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdSelectBuffer(m, []string{"a.txt", "b.txt"}, false)
+
+		if m.activeWindow.Buffer.Filename != "a.txt" {
+			t.Errorf("expected active buffer to remain a.txt, got %q", m.activeWindow.Buffer.Filename)
+		}
+	})
+}
+
+// ==================================================
+// TestCmdDeleteBuffer Tests
+// ==================================================
+
+func TestCmdDeleteBuffer(t *testing.T) {
+
+	// --------------------------------------------------
+	// Group 1: No args (unlist current buffer)
+	// --------------------------------------------------
+
+	t.Run("no-args marks current buffer as unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if buf1.Listed {
+			t.Error("expected buf1.Listed to be false after unlisting")
+		}
+	})
+
+	t.Run("no-args keeps buffer in m.buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		found := false
+		for _, b := range m.buffers {
+			if b.Id == buf1.Id {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Error("expected buf1 to remain in m.buffers after unlisting")
+		}
+	})
+
+	t.Run("no-args does not unlist other buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if !buf2.Listed {
+			t.Error("expected buf2.Listed to remain true")
+		}
+	})
+
+	t.Run("no-args switches active window to another listed buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if m.activeWindow.Buffer.Id == buf1.Id {
+			t.Error("expected active window to switch away from unlisted buf1")
+		}
+		if m.activeWindow.Buffer.Id != buf2.Id {
+			t.Errorf("expected active window to show buf2, got buffer id %d", m.activeWindow.Buffer.Id)
+		}
+	})
+
+	t.Run("no-args with modified buffer and no force sets error, does not unlist", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for modified buffer without force")
+		}
+		if !buf1.Listed {
+			t.Error("expected buf1.Listed to remain true when unlisting is blocked")
+		}
+	})
+
+	t.Run("no-args with modified buffer and force unlists successfully", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, true)
+
+		if buf1.Listed {
+			t.Error("expected buf1.Listed to be false with force=true")
+		}
+	})
+
+	t.Run("no-args sets no error on success", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if m.commandOutput != nil && m.commandOutput.IsError {
+			t.Error("expected no error CommandOutput on successful unlisting")
+		}
+	})
+
+	t.Run("no-args returns nil tea.Cmd on success", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdDeleteBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	t.Run("no-args returns nil tea.Cmd on error (modified, no force)", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdDeleteBuffer(m, []string{}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd even when error is set")
+		}
+	})
+
+	t.Run("error output is inline for modified buffer guard", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Modified().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected commandOutput to be set")
+		}
+		if !m.commandOutput.Inline {
+			t.Error("expected commandOutput.Inline to be true")
+		}
+	})
+
+	// --------------------------------------------------
+	// Group 2: Unlist by numeric ID
+	// --------------------------------------------------
+
+	t.Run("unlist by ID marks correct buffer as unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false after unlisting by ID")
+		}
+	})
+
+	t.Run("unlist by ID keeps buffer in m.buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		found := false
+		for _, b := range m.buffers {
+			if b.Id == buf2.Id {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Error("expected buf2 to remain in m.buffers after unlisting")
+		}
+	})
+
+	t.Run("unlist by ID does not affect other buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if !buf1.Listed {
+			t.Error("expected buf1.Listed to remain true")
+		}
+		if !buf3.Listed {
+			t.Error("expected buf3.Listed to remain true")
+		}
+	})
+
+	t.Run("unlist non-active buffer by ID does not change active window buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if m.activeWindow.Buffer.Id != buf1.Id {
+			t.Errorf("expected active window to remain on buf1, got buffer id %d", m.activeWindow.Buffer.Id)
+		}
+	})
+
+	t.Run("unknown numeric ID sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		cmdDeleteBuffer(m, []string{"99999"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for unknown buffer ID")
+		}
+	})
+
+	t.Run("unknown numeric ID does not unlist any buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		cmdDeleteBuffer(m, []string{"99999"}, false)
+
+		if !buf1.Listed {
+			t.Error("expected buf1.Listed to remain true for unknown ID")
+		}
+	})
+
+	t.Run("unlist by ID with modified buffer and no force sets error, does not unlist", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Modified().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for modified buffer without force")
+		}
+		if !buf2.Listed {
+			t.Error("expected buf2.Listed to remain true when unlisting is blocked")
+		}
+	})
+
+	t.Run("unlist by ID with modified buffer and force unlists successfully", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Modified().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, true)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false with force=true")
+		}
+	})
+
+	t.Run("unlist by ID returns nil tea.Cmd on success", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	// --------------------------------------------------
+	// Group 3: Unlist by filename / substring
+	// --------------------------------------------------
+
+	t.Run("unlist by exact filename marks correct buffer as unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{"b.txt"}, false)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false after unlisting by filename")
+		}
+	})
+
+	t.Run("unlist by exact filename keeps buffer in m.buffers", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{"b.txt"}, false)
+
+		found := false
+		for _, b := range m.buffers {
+			if b.Id == buf2.Id {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Error("expected buf2 to remain in m.buffers after unlisting")
+		}
+	})
+
+	t.Run("unlist by unique substring marks correct buffer as unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("alpha.go").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("beta.go").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// "lpha" uniquely identifies alpha.go
+		cmdDeleteBuffer(m, []string{"lpha"}, false)
+
+		if buf1.Listed {
+			t.Error("expected buf1 (alpha.go).Listed to be false after unlisting by substring")
+		}
+	})
+
+	t.Run("unlist by partial path component marks correct buffer as unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("src/foo/main.go").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("src/bar/main.go").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// "foo" uniquely identifies src/foo/main.go
+		cmdDeleteBuffer(m, []string{"foo"}, false)
+
+		if buf1.Listed {
+			t.Error("expected buf1 (src/foo/main.go).Listed to be false after unlisting by path component")
+		}
+	})
+
+	t.Run("ambiguous substring sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		// ".txt" matches both buffers
+		cmdDeleteBuffer(m, []string{".txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for ambiguous substring")
+		}
+	})
+
+	t.Run("ambiguous substring does not unlist any buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{".txt"}, false)
+
+		if !buf1.Listed {
+			t.Error("expected buf1.Listed to remain true for ambiguous match")
+		}
+		if !buf2.Listed {
+			t.Error("expected buf2.Listed to remain true for ambiguous match")
+		}
+	})
+
+	t.Run("unknown filename sets error output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		cmdDeleteBuffer(m, []string{"nope.txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for unknown filename")
+		}
+	})
+
+	t.Run("unknown filename does not unlist any buffer", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		cmdDeleteBuffer(m, []string{"nope.txt"}, false)
+
+		if !buf1.Listed {
+			t.Error("expected buf1.Listed to remain true for unknown filename")
+		}
+	})
+
+	t.Run("unlist non-active buffer by filename does not change active window", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{"b.txt"}, false)
+
+		if m.activeWindow.Buffer.Id != buf1.Id {
+			t.Errorf("expected active window to remain on buf1, got buffer id %d", m.activeWindow.Buffer.Id)
+		}
+	})
+
+	t.Run("unlist by filename returns nil tea.Cmd on success", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmd := cmdDeleteBuffer(m, []string{"b.txt"}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	// --------------------------------------------------
+	// Group 4: Multiple args
+	// --------------------------------------------------
+
+	t.Run("two IDs: both buffers unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{
+			fmt.Sprintf("%d", buf2.Id),
+			fmt.Sprintf("%d", buf3.Id),
+		}, false)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false")
+		}
+		if buf3.Listed {
+			t.Error("expected buf3.Listed to be false")
+		}
+	})
+
+	t.Run("two filenames: both buffers unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{"b.txt", "c.txt"}, false)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false")
+		}
+		if buf3.Listed {
+			t.Error("expected buf3.Listed to be false")
+		}
+	})
+
+	t.Run("mixed ID and filename: both buffers unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{
+			fmt.Sprintf("%d", buf2.Id),
+			"c.txt",
+		}, false)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false")
+		}
+		if buf3.Listed {
+			t.Error("expected buf3.Listed to be false")
+		}
+	})
+
+	t.Run("multiple modified buffers with force: all unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Modified().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Modified().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{"b.txt", "c.txt"}, true)
+
+		if buf2.Listed {
+			t.Error("expected buf2.Listed to be false with force=true")
+		}
+		if buf3.Listed {
+			t.Error("expected buf3.Listed to be false with force=true")
+		}
+	})
+
+	t.Run("multiple modified buffers without force: error set, none unlisted", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Modified().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Modified().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmdDeleteBuffer(m, []string{"b.txt", "c.txt"}, false)
+
+		if m.commandOutput == nil || !m.commandOutput.IsError {
+			t.Error("expected an error CommandOutput for modified buffers without force")
+		}
+		if !buf2.Listed {
+			t.Error("expected buf2.Listed to remain true when unlisting is blocked")
+		}
+		if !buf3.Listed {
+			t.Error("expected buf3.Listed to remain true when unlisting is blocked")
+		}
+	})
+
+	t.Run("multiple args returns nil tea.Cmd on success", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+		buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2, &buf3}
+
+		cmd := cmdDeleteBuffer(m, []string{"b.txt", "c.txt"}, false)
+
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd")
+		}
+	})
+
+	// --------------------------------------------------
+	// Group 5: Window handling
+	// --------------------------------------------------
+
+	// BUG: We do not actually handle window switching yet. The entire application runs in a single window
+
+	// t.Run("unlisting active buffer causes active window to switch to another listed buffer", func(t *testing.T) {
+	// 	buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+	// 	buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+	//
+	// 	win1 := core.NewWindowBuilder().WithBuffer(&buf1).WithHeight(24).WithWidth(80).Build()
+	//
+	// 	m := &mockModel{
+	// 		windows:      []*core.Window{&win1},
+	// 		activeWindow: &win1,
+	// 		buffers:      []*core.Buffer{&buf1, &buf2},
+	// 		settings:     core.NewDefaultSettings(),
+	// 		mode:         core.NormalMode,
+	// 		registers:    core.DefaultRegisters(),
+	// 	}
+	//
+	// 	cmdDeleteBuffer(m, []string{}, false)
+	//
+	// 	if m.activeWindow.Buffer.Id == buf1.Id {
+	// 		t.Error("expected active window to switch away from unlisted buf1")
+	// 	}
+	// })
+	//
+	// t.Run("unlisting buffer displayed in a non-active window causes that window to switch", func(t *testing.T) {
+	// 	buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+	// 	buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+	// 	buf3 := core.NewBufferBuilder().WithFilename("c.txt").Listed().Build()
+	//
+	// 	win1 := core.NewWindowBuilder().WithBuffer(&buf1).WithHeight(24).WithWidth(80).Build()
+	// 	win2 := core.NewWindowBuilder().WithBuffer(&buf2).WithHeight(24).WithWidth(80).Build()
+	//
+	// 	m := &mockModel{
+	// 		windows:      []*core.Window{&win1, &win2},
+	// 		activeWindow: &win1,
+	// 		buffers:      []*core.Buffer{&buf1, &buf2, &buf3},
+	// 		settings:     core.NewDefaultSettings(),
+	// 		mode:         core.NormalMode,
+	// 		registers:    core.DefaultRegisters(),
+	// 	}
+	//
+	// 	// Unlist buf2, which is only displayed in the non-active win2
+	// 	cmdDeleteBuffer(m, []string{fmt.Sprintf("%d", buf2.Id)}, false)
+	//
+	// 	if win2.Buffer.Id == buf2.Id {
+	// 		t.Error("expected win2 to switch away from unlisted buf2")
+	// 	}
+	// })
+	//
+	// t.Run("unlisting buffer displayed in two windows causes both to switch", func(t *testing.T) {
+	// 	buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+	// 	buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+	//
+	// 	win1 := core.NewWindowBuilder().WithBuffer(&buf1).WithHeight(24).WithWidth(80).Build()
+	// 	win2 := core.NewWindowBuilder().WithBuffer(&buf1).WithHeight(24).WithWidth(80).Build()
+	//
+	// 	m := &mockModel{
+	// 		windows:      []*core.Window{&win1, &win2},
+	// 		activeWindow: &win1,
+	// 		buffers:      []*core.Buffer{&buf1, &buf2},
+	// 		settings:     core.NewDefaultSettings(),
+	// 		mode:         core.NormalMode,
+	// 		registers:    core.DefaultRegisters(),
+	// 	}
+	//
+	// 	// Both windows display buf1; unlist buf1
+	// 	cmdDeleteBuffer(m, []string{}, false)
+	//
+	// 	if win1.Buffer.Id == buf1.Id {
+	// 		t.Error("expected win1 to switch away from unlisted buf1")
+	// 	}
+	// 	if win2.Buffer.Id == buf1.Id {
+	// 		t.Error("expected win2 to switch away from unlisted buf1")
+	// 	}
+	// })
+
+	// --------------------------------------------------
+	// Group 6: Return values and side-effect consistency
+	// --------------------------------------------------
+
+	t.Run("returns nil tea.Cmd in all error cases", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		// Error case: unknown ID
+		cmd := cmdDeleteBuffer(m, []string{"99999"}, false)
+		if cmd != nil {
+			t.Error("expected nil tea.Cmd even when error is set (unknown ID)")
+		}
+	})
+
+	t.Run("no error output on successful unlist by filename", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+		buf2 := core.NewBufferBuilder().WithFilename("b.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+		m.buffers = []*core.Buffer{&buf1, &buf2}
+
+		cmdDeleteBuffer(m, []string{"b.txt"}, false)
+
+		if m.commandOutput != nil && m.commandOutput.IsError {
+			t.Error("expected no error CommandOutput on successful unlist by filename")
+		}
+	})
+
+	t.Run("all errors use inline output", func(t *testing.T) {
+		buf1 := core.NewBufferBuilder().WithFilename("a.txt").Listed().Build()
+
+		m := newMockModelWithBuffer(&buf1)
+
+		// Error case: unknown filename
+		cmdDeleteBuffer(m, []string{"nope.txt"}, false)
+
+		if m.commandOutput == nil {
+			t.Fatal("expected commandOutput to be set")
+		}
+		if !m.commandOutput.Inline {
+			t.Error("expected commandOutput.Inline to be true for all errors")
+		}
+	})
+}
diff --git a/internal/command/registry.go b/internal/command/registry.go
index cb69f96..350f35b 100644
--- a/internal/command/registry.go
+++ b/internal/command/registry.go
@@ -10,8 +10,8 @@ import (
 
 // Command: Represents a command that can be executed from command mode.
 type Command struct {
-	Name      string                                             // Full name: "quit"
-	ShortForm string                                             // Minimum abbreviation: "q"
+	Name      string                                                  // Full name: "quit"
+	ShortForm string                                                  // Minimum abbreviation: "q"
 	Handler   func(m action.Model, args []string, force bool) tea.Cmd // Handler function
 }
 
@@ -162,6 +162,55 @@ func (r *Registry) registerDefaults() {
 		Handler:   cmdRegisters,
 	})
 
+	// Buffer commands
+	r.Register(Command{
+		Name:      "buffers",
+		ShortForm: "buffers",
+		Handler:   cmdListBuffers,
+	})
+
+	r.Register(Command{
+		Name:      "ls",
+		ShortForm: "ls",
+		Handler:   cmdListBuffers,
+	})
+
+	r.Register(Command{
+		Name:      "bn",
+		ShortForm: "bn",
+		Handler:   cmdNextBuffer,
+	})
+
+	r.Register(Command{
+		Name:      "bp",
+		ShortForm: "bp",
+		Handler:   cmdPrevBuffer,
+	})
+
+	r.Register(Command{
+		Name:      "bf",
+		ShortForm: "bf",
+		Handler:   cmdFirstBuffer,
+	})
+
+	r.Register(Command{
+		Name:      "bl",
+		ShortForm: "bl",
+		Handler:   cmdLastBuffer,
+	})
+
+	r.Register(Command{
+		Name:      "b",
+		ShortForm: "b",
+		Handler:   cmdSelectBuffer,
+	})
+
+	r.Register(Command{
+		Name:      "bdelete",
+		ShortForm: "bd",
+		Handler:   cmdDeleteBuffer,
+	})
+
 	// File commands
 	r.Register(Command{
 		Name:      "edit",