diff --git a/internal/app/app.go b/internal/app/app.go
index a9deca5..e7f8dba 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -69,6 +69,7 @@ func NewAppGiBack(version string, verbose, dryRun bool) *App {
 // ANSI escape code for gray color.
 const (
 	yellowColor = "\033[33m"
+	orangeColor = "\033[38;5;208m"
 	grayColor   = "\033[90m"
 	redColor    = "\033[31m"
 	resetColor  = "\033[0m"
@@ -108,9 +109,14 @@ func (a *App) logDebugf(format string, args ...any) {
 	_, _ = fmt.Fprintf(os.Stderr, yellowColor+a.getAppName()+" ⚙️: "+grayColor+format+resetColor+"\n", args...)
 }
 
-// logWarnf writes error messages to stderr.
+// logErrorf writes error messages to stderr.
+func (a *App) logErrorf(format string, args ...any) {
+	_, _ = fmt.Fprintf(os.Stderr, redColor+a.getAppName()+" ❌️: "+grayColor+format+resetColor+"\n", args...)
+}
+
+// logWarnf writes warning (soft error) messages to stderr.
 func (a *App) logWarnf(format string, args ...any) {
-	_, _ = fmt.Fprintf(os.Stderr, redColor+a.getAppName()+" ❌: "+grayColor+format+resetColor+"\n", args...)
+	_, _ = fmt.Fprintf(os.Stderr, orangeColor+a.getAppName()+" ⚠️: "+grayColor+format+resetColor+"\n", args...)
 }
 
 // logInfof writes info messages to stderr.
@@ -168,7 +174,7 @@ func (a *App) Run(args []string) (err error) {
 		// Get the last undoed entry (from current reference)
 		lastEntry, err := lgr.GetLastEntry()
 		if err != nil {
-			a.logWarnf("something wrong with the log: %v", err)
+			a.logErrorf("something wrong with the log: %v", err)
 			return nil
 		}
 		if lastEntry == nil || !lastEntry.Undoed {
@@ -201,15 +207,28 @@ func (a *App) Run(args []string) (err error) {
 	// Get the last git command
 	var lastEntry *logging.Entry
 	if a.isBackMode {
-		// For git-back, only look for checkout/switch commands
-		lastEntry, err = lgr.GetLastCheckoutSwitchEntry()
+		// For git-back, look for the last checkout/switch command (including undoed ones for toggle behavior)
+		// We pass "any" to look across all refs, not just the current one
+		lastEntry, err = lgr.GetLastEntry(logging.RefAny)
 		if err != nil {
-			return fmt.Errorf("failed to get last checkout/switch command: %w", err)
+			return fmt.Errorf("failed to get last command: %w", err)
 		}
 		if lastEntry == nil {
-			a.logDebugf("no checkout/switch commands to undo")
+			a.logDebugf("no commands found")
 			return nil
 		}
+		// Check if the last command was a checkout or switch command
+		if !a.isCheckoutOrSwitchCommand(lastEntry.Command) {
+			// If not, try to find the last checkout/switch command (including undoed ones for toggle behavior)
+			lastEntry, err = lgr.GetLastCheckoutSwitchEntryForToggle(logging.RefAny)
+			if err != nil {
+				return fmt.Errorf("failed to get last checkout/switch command: %w", err)
+			}
+			if lastEntry == nil {
+				a.logDebugf("no checkout/switch commands to undo")
+				return nil
+			}
+		}
 	} else {
 		// For git-undo, get any regular entry
 		lastEntry, err = lgr.GetLastRegularEntry()
@@ -238,25 +257,37 @@ func (a *App) Run(args []string) (err error) {
 		u = undoer.New(lastEntry.Command, g)
 	}
 
-	// Get the undo command
-	undoCmd, err := u.GetUndoCommand()
+	// Get the undo commands
+	undoCmds, err := u.GetUndoCommands()
 	if err != nil {
 		return err
 	}
 
 	if a.dryRun {
-		a.logDebugf("Would run: %s\n", undoCmd.Command)
-		if len(undoCmd.Warnings) > 0 {
-			for _, warning := range undoCmd.Warnings {
-				a.logWarnf("%s", warning)
+		for _, undoCmd := range undoCmds {
+			a.logDebugf("Would run: %s\n", undoCmd.Command)
+			if len(undoCmd.Warnings) > 0 {
+				for _, warning := range undoCmd.Warnings {
+					a.logWarnf("%s", warning)
+				}
 			}
 		}
 		return nil
 	}
 
-	// Execute the undo command
-	if err := undoCmd.Exec(); err != nil {
-		return fmt.Errorf("failed to execute undo command %s via %s: %w", lastEntry.Command, undoCmd.Command, err)
+	// Execute the undo commands
+	for i, undoCmd := range undoCmds {
+		if err := undoCmd.Exec(); err != nil {
+			return fmt.Errorf("failed to execute undo command %d/%d %s via %s: %w",
+				i+1, len(undoCmds), lastEntry.Command, undoCmd.Command, err)
+		}
+		a.logDebugf("Successfully executed undo command %d/%d: %s via %s",
+			i+1, len(undoCmds), lastEntry.Command, undoCmd.Command)
+		if len(undoCmd.Warnings) > 0 {
+			for _, warning := range undoCmd.Warnings {
+				a.logWarnf("%s", warning)
+			}
+		}
 	}
 
 	// Mark the entry as undoed in the log
@@ -264,11 +295,11 @@ func (a *App) Run(args []string) (err error) {
 		a.logWarnf("Failed to mark command as undoed: %v", err)
 	}
 
-	a.logDebugf("Successfully undid: %s via %s", lastEntry.Command, undoCmd.Command)
-	if len(undoCmd.Warnings) > 0 {
-		for _, warning := range undoCmd.Warnings {
-			a.logWarnf("%s", warning)
-		}
+	// Summary message for all commands
+	if len(undoCmds) == 1 {
+		a.logDebugf("Successfully undid: %s via %s", lastEntry.Command, undoCmds[0].Command)
+	} else {
+		a.logDebugf("Successfully undid: %s via %d commands", lastEntry.Command, len(undoCmds))
 	}
 	return nil
 }
diff --git a/internal/app/app_test.go b/internal/app/app_test.go
index dd58e9a..5de996c 100644
--- a/internal/app/app_test.go
+++ b/internal/app/app_test.go
@@ -119,12 +119,17 @@ func (s *GitTestSuite) TestUndoAdd() {
 
 // TestSequentialUndo tests multiple undo operations in sequence.
 func (s *GitTestSuite) TestSequentialUndo() {
-	s.T().Skip("TODO FIX ME ")
+	// Setup: Create an initial base commit so we're not working from the root commit
+	initialFile := filepath.Join(s.GetRepoDir(), "initial.txt")
+	err := os.WriteFile(initialFile, []byte("initial content"), 0644)
+	s.Require().NoError(err)
+	s.Git("add", filepath.Base(initialFile))
+	s.Git("commit", "-m", "Initial base commit")
 
 	// Create test files
 	file1 := filepath.Join(s.GetRepoDir(), "file1.txt")
 	file2 := filepath.Join(s.GetRepoDir(), "file2.txt")
-	err := os.WriteFile(file1, []byte("content1"), 0644)
+	err = os.WriteFile(file1, []byte("content1"), 0644)
 	s.Require().NoError(err)
 	err = os.WriteFile(file2, []byte("content2"), 0644)
 	s.Require().NoError(err)
@@ -145,6 +150,7 @@ func (s *GitTestSuite) TestSequentialUndo() {
 	s.gitUndo()
 	status = s.RunCmd("git", "status", "--porcelain")
 	s.Contains(status, "A  file2.txt", "file2.txt should be staged after undoing second commit")
+	s.NotContains(status, "A  file1.txt", "file1.txt should not be staged after undoing second commit")
 
 	// Second undo: should unstage file2.txt
 	s.gitUndo()
@@ -174,12 +180,12 @@ func (s *GitTestSuite) TestUndoLog() {
 
 	// Perform some git operations to generate log entries
 	s.Git("add", filepath.Base(testFile)) // Use relative path for git commands
-	s.Git("commit", "-m", "'First commit'")
+	s.Git("commit", "-m", "First commit")
 
 	// Check that log command works and shows output
 	log := s.gitUndoLog()
 	s.NotEmpty(log, "Log should not be empty")
-	s.Contains(log, "git commit -m 'First commit'", "Log should contain commit command")
+	s.Contains(log, "git commit -m First commit", "Log should contain commit command")
 	s.Contains(log, "git add test.txt", "Log should contain add command")
 	s.Contains(log, "|feature-branch|", "Log should contain branch name")
 
diff --git a/internal/git-undo/logging/logger.go b/internal/git-undo/logging/logger.go
index a89b39c..67173ce 100644
--- a/internal/git-undo/logging/logger.go
+++ b/internal/git-undo/logging/logger.go
@@ -53,12 +53,30 @@ func (et EntryType) String() string {
 	return [...]string{"", "regular", "undoed"}[et]
 }
 
+type Ref string
+
+const (
+	// RefAny means when the ref (branch/tag/commit) of the line is not respected (any).
+	RefAny Ref = "__ANY__"
+
+	// RefCurrent means when the ref (branch/tag/commit) is the current one.
+	RefCurrent Ref = "__CURRENT__"
+
+	// RefUnknown means when the ref couldn't be determined. (Non-happy path).
+	RefUnknown Ref = "__UNKNOWN__"
+
+	// RefMain represents the main branch (used for convenience).
+	RefMain Ref = "main"
+)
+
+func (r Ref) String() string { return string(r) }
+
 // Entry represents a logged git command with its full identifier.
 type Entry struct {
 	// Timestamp is parsed timestamp of the entry.
 	Timestamp time.Time
 	// Ref is reference (branch/tag/commit) where the command was executed.
-	Ref string
+	Ref Ref
 	// Command is just the command part.
 	Command string
 
@@ -106,7 +124,7 @@ func (e *Entry) UnmarshalText(data []byte) error {
 		return fmt.Errorf("failed to parse timestamp: %w", err)
 	}
 
-	e.Ref = parts[1]
+	e.Ref = Ref(parts[1])
 	e.Command = parts[2]
 
 	return nil
@@ -143,17 +161,17 @@ func (l *Logger) LogCommand(strGitCommand string) error {
 	}
 
 	// Get current ref (branch/tag/commit)
-	ref, err := l.git.GetCurrentGitRef()
-	if err != nil {
-		// If we can't get the ref, just use "unknown"
-		ref = "unknown"
+	var ref = RefUnknown
+	refStr, err := l.git.GetCurrentGitRef()
+	if err == nil {
+		ref = Ref(refStr)
 	}
 
 	return l.logCommandWithDedup(strGitCommand, ref)
 }
 
 // logCommandWithDedup logs a command while preventing duplicates between shell and git hooks.
-func (l *Logger) logCommandWithDedup(strGitCommand, ref string) error {
+func (l *Logger) logCommandWithDedup(strGitCommand string, ref Ref) error {
 	// Create a unique identifier for this command + timestamp (within 2 seconds)
 	// This allows us to detect and prevent duplicates between shell and git hooks
 	normalizedTime := time.Now().Truncate(2 * time.Second)
@@ -184,7 +202,7 @@ func (l *Logger) logCommandWithDedup(strGitCommand, ref string) error {
 }
 
 // createCommandIdentifier creates a short identifier for a command to detect duplicates.
-func (l *Logger) createCommandIdentifier(command, ref string, timestamp time.Time) string {
+func (l *Logger) createCommandIdentifier(command string, ref Ref, timestamp time.Time) string {
 	// Normalize the command first to ensure equivalent commands have the same identifier
 	normalizedCmd := l.normalizeGitCommand(command)
 
@@ -353,24 +371,11 @@ func (l *Logger) ToggleEntry(entryIdentifier string) error {
 
 // GetLastRegularEntry returns last regular entry (ignoring undoed ones)
 // for the given ref (or current ref if not specified).
-func (l *Logger) GetLastRegularEntry(refArg ...string) (*Entry, error) {
+func (l *Logger) GetLastRegularEntry(refArg ...Ref) (*Entry, error) {
 	if l.err != nil {
 		return nil, fmt.Errorf("logger is not healthy: %w", l.err)
 	}
-
-	// Determine which reference to use
-	var ref string
-	switch len(refArg) {
-	case 0:
-		// No ref provided, use current ref
-		currentRef, err := l.git.GetCurrentGitRef()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get current ref: %w", err)
-		}
-		ref = currentRef
-	default:
-		ref = refArg[0]
-	}
+	ref := l.resolveRef(refArg...)
 
 	var foundEntry *Entry
 	err := l.processLogFile(func(line string) bool {
@@ -381,12 +386,11 @@ func (l *Logger) GetLastRegularEntry(refArg ...string) (*Entry, error) {
 
 		// Parse the log line into an Entry
 		entry, err := parseLogLine(line)
-		if err != nil { // TODO: warnings maybe?
+		if err != nil { // TODO: Logger.lgr should display warnings in Verbose mode here
 			return true
 		}
 
-		// Check reference if specified and not "any"
-		if ref != "" && entry.Ref != ref {
+		if !l.matchRef(entry.Ref, ref) {
 			return true
 		}
 
@@ -403,24 +407,12 @@ func (l *Logger) GetLastRegularEntry(refArg ...string) (*Entry, error) {
 
 // GetLastEntry returns last entry for the given ref (or current ref if not specified)
 // regarding of the entry type (undoed or regular).
-func (l *Logger) GetLastEntry(refArg ...string) (*Entry, error) {
+func (l *Logger) GetLastEntry(refArg ...Ref) (*Entry, error) {
 	if l.err != nil {
 		return nil, fmt.Errorf("logger is not healthy: %w", l.err)
 	}
 
-	// Determine which reference to use
-	var ref string
-	switch len(refArg) {
-	case 0:
-		// No ref provided, use current ref
-		currentRef, err := l.git.GetCurrentGitRef()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get current ref: %w", err)
-		}
-		ref = currentRef
-	default:
-		ref = refArg[0]
-	}
+	ref := l.resolveRef(refArg...)
 
 	var foundEntry *Entry
 	err := l.processLogFile(func(line string) bool {
@@ -430,8 +422,7 @@ func (l *Logger) GetLastEntry(refArg ...string) (*Entry, error) {
 			return true
 		}
 
-		// Check reference if specified and not "any"
-		if ref != "" && entry.Ref != ref {
+		if !l.matchRef(entry.Ref, ref) {
 			return true
 		}
 
@@ -448,24 +439,12 @@ func (l *Logger) GetLastEntry(refArg ...string) (*Entry, error) {
 
 // GetLastCheckoutSwitchEntry returns the last checkout or switch command entry
 // for the given ref (or current ref if not specified).
-func (l *Logger) GetLastCheckoutSwitchEntry(refArg ...string) (*Entry, error) {
+func (l *Logger) GetLastCheckoutSwitchEntry(refArg ...Ref) (*Entry, error) {
 	if l.err != nil {
 		return nil, fmt.Errorf("logger is not healthy: %w", l.err)
 	}
 
-	// Determine which reference to use
-	var ref string
-	switch len(refArg) {
-	case 0:
-		// No ref provided, use current ref
-		currentRef, err := l.git.GetCurrentGitRef()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get current ref: %w", err)
-		}
-		ref = currentRef
-	default:
-		ref = refArg[0]
-	}
+	ref := l.resolveRef(refArg...)
 
 	var foundEntry *Entry
 	err := l.processLogFile(func(line string) bool {
@@ -479,9 +458,7 @@ func (l *Logger) GetLastCheckoutSwitchEntry(refArg ...string) (*Entry, error) {
 		if err != nil { // TODO: warnings maybe?
 			return true
 		}
-
-		// Check reference if specified and not "any"
-		if ref != "" && entry.Ref != ref {
+		if !l.matchRef(entry.Ref, ref) {
 			return true
 		}
 
@@ -501,6 +478,42 @@ func (l *Logger) GetLastCheckoutSwitchEntry(refArg ...string) (*Entry, error) {
 	return foundEntry, nil
 }
 
+// GetLastCheckoutSwitchEntryForToggle returns the last checkout or switch command entry
+// for git-back, including undoed entries. This allows git-back to toggle back and forth.
+func (l *Logger) GetLastCheckoutSwitchEntryForToggle(refArg ...Ref) (*Entry, error) {
+	if l.err != nil {
+		return nil, fmt.Errorf("logger is not healthy: %w", l.err)
+	}
+
+	ref := l.resolveRef(refArg...)
+
+	var foundEntry *Entry
+	err := l.processLogFile(func(line string) bool {
+		// Parse the log line into an Entry (including undoed entries)
+		entry, err := parseLogLine(line)
+		if err != nil { // TODO: warnings maybe?
+			return true
+		}
+		if !l.matchRef(entry.Ref, ref) {
+			return true
+		}
+
+		// Check if this is a checkout or switch command
+		if !isCheckoutOrSwitchCommand(entry.Command) {
+			return true
+		}
+
+		// Found a matching entry (even if undoed)!
+		foundEntry = entry
+		return false
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return foundEntry, nil
+}
+
 // isCheckoutOrSwitchCommand checks if a command is a git checkout or git switch command.
 func isCheckoutOrSwitchCommand(command string) bool {
 	// Parse the command to check its type
@@ -518,29 +531,17 @@ func (l *Logger) Dump(w io.Writer) error {
 		return fmt.Errorf("logger is not healthy: %w", l.err)
 	}
 
-	// Check if file exists
-	_, err := os.Stat(l.logFile)
-	if os.IsNotExist(err) {
-		// File doesn't exist, create an empty one
-		if err := os.WriteFile(l.logFile, []byte{}, 0600); err != nil {
-			return fmt.Errorf("failed to create log file: %w", err)
-		}
-		// Nothing to dump (file is empty)
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to check log file status: %w", err)
-	}
-
-	// Open the file for reading
-	file, err := os.Open(l.logFile)
+	file, err := l.getFile()
 	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // nothing to dump (file is empty)
+		}
 		return fmt.Errorf("failed to open log file: %w", err)
 	}
 	defer func() { _ = file.Close() }()
 
 	// Copy directly from file to writer
-	_, err = io.Copy(w, file)
-	if err != nil {
+	if _, err = io.Copy(w, file); err != nil {
 		return fmt.Errorf("failed to dump log file: %w", err)
 	}
 
@@ -567,19 +568,17 @@ func (l *Logger) prependLogEntry(entry string) error {
 		return fmt.Errorf("failed to write log entry: %w", err)
 	}
 
-	// Stream original file into the tmp file
-	in, err := os.Open(l.logFile)
-	switch {
-	case err == nil:
-		defer func() { _ = in.Close() }()
-
+	in, err := l.getFile()
+	if err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	// if file exists, stream original file into the tmp file
+	if in != nil {
+		// Stream original file into the tmp file
 		if _, err := io.Copy(out, in); err != nil {
 			return fmt.Errorf("failed to copy existing log content: %w", err)
 		}
-	case os.IsNotExist(err):
-		// if os.Open failed because file doesn't exist, we just skip it
-	default:
-		return fmt.Errorf("failed to open log file: %w", err)
+		defer func() { _ = in.Close() }()
 	}
 
 	// Swap via rename: will remove logFile and make tmpFile our logFile
@@ -590,6 +589,35 @@ func (l *Logger) prependLogEntry(entry string) error {
 	return nil
 }
 
+// resolveRef resolves the ref argument to a Ref.
+func (l *Logger) resolveRef(refArg ...Ref) Ref {
+	if len(refArg) == 0 || refArg[0] == RefCurrent {
+		// No ref provided, use current ref
+		currentRef, err := l.git.GetCurrentGitRef()
+		if err != nil {
+			return RefAny
+		}
+		return Ref(currentRef)
+	}
+
+	return refArg[0]
+}
+
+// matchRef checks if a line ref matches a target ref.
+func (l *Logger) matchRef(lineRef, targetRef Ref) bool {
+	if targetRef == RefAny {
+		return true
+	}
+	if targetRef == RefCurrent {
+		panic("matchRef MUST be called after RefCurrent is resolved")
+	}
+	if targetRef == RefUnknown {
+		panic("matchRef MUST be not be called with RefUnknown")
+	}
+
+	return lineRef == targetRef
+}
+
 // processLogFile reads the log file line by line and calls the processor function for each line.
 // This is more efficient than reading the entire file at once, especially when only
 // the first few lines are needed.
@@ -599,22 +627,12 @@ func (l *Logger) processLogFile(processor lineProcessor) error {
 	}
 
 	// Check if the file exists
-	_, err := os.Stat(l.logFile)
-	if os.IsNotExist(err) {
-		// Create the file if it doesn't exist
-		if err := os.WriteFile(l.logFile, []byte{}, 0600); err != nil {
-			return fmt.Errorf("failed to create log file: %w", err)
-		}
-
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to check log file status: %w", err)
-	}
-
-	// Open the file for reading
-	file, err := os.Open(l.logFile)
+	file, err := l.getFile()
 	if err != nil {
-		return fmt.Errorf("failed to open log file: %w", err)
+		if os.IsNotExist(err) {
+			return nil // will log error OR nil if file doesn't exist
+		}
+		return err
 	}
 	defer file.Close()
 
@@ -642,6 +660,28 @@ func (l *Logger) processLogFile(processor lineProcessor) error {
 	return nil
 }
 
+// getFile returns the os.File for the log file.
+// It opens it for reading. If file doesn't exist it creates it (but still returns os.ErrNotExist).
+// User is responsible for closing the file.
+func (l *Logger) getFile() (*os.File, error) {
+	// Check if the file exists
+	_, err := os.Stat(l.logFile)
+	if os.IsNotExist(err) {
+		// Create the file if it doesn't exist
+		// TODO: should we stick to os.Create() instead?
+		if err := os.WriteFile(l.logFile, []byte{}, 0600); err != nil {
+			return nil, fmt.Errorf("failed to create log file: %w", err)
+		}
+
+		return nil, err
+	} else if err != nil {
+		return nil, fmt.Errorf("failed to check log file status: %w", err)
+	}
+
+	// Open the file for reading or writing
+	return os.OpenFile(l.logFile, os.O_RDONLY, 0600)
+}
+
 // parseLogLine parses a log line into an Entry.
 // Format: {"d":"2025-05-16 11:02:55","ref":"main","cmd":"git commit -m 'test'"}.
 func parseLogLine(line string) (*Entry, error) {
diff --git a/internal/git-undo/logging/logger_test.go b/internal/git-undo/logging/logger_test.go
index 3de03f1..e33a3e6 100644
--- a/internal/git-undo/logging/logger_test.go
+++ b/internal/git-undo/logging/logger_test.go
@@ -28,7 +28,7 @@ func (m *MockGitRefSwitcher) SwitchRef(ref string) {
 
 func NewMockGitHelper() *MockGitRefSwitcher {
 	return &MockGitRefSwitcher{
-		currentRef: "main",
+		currentRef: logging.RefMain.String(),
 	}
 }
 
@@ -87,7 +87,7 @@ func TestLogger_E2E(t *testing.T) {
 	entry, err := lgr.GetLastRegularEntry()
 	require.NoError(t, err)
 	assert.Equal(t, commands[4].cmd, entry.Command)
-	assert.Equal(t, "feature/test", entry.Ref)
+	assert.Equal(t, "feature/test", entry.Ref.String())
 
 	// 3. Toggle the latest entry as undoed
 	t.Log("Toggling latest entry as undoed...")
@@ -106,12 +106,12 @@ func TestLogger_E2E(t *testing.T) {
 
 	// 6. Switch to main branch and get its latest entry
 	t.Log("Getting latest entry from main branch...")
-	SwitchRef(mgc, "main")
+	SwitchRef(mgc, logging.RefMain.String())
 
 	mainEntry, err := lgr.GetLastRegularEntry()
 	require.NoError(t, err)
 	assert.Equal(t, commands[1].cmd, mainEntry.Command)
-	assert.Equal(t, "main", mainEntry.Ref)
+	assert.Equal(t, logging.RefMain, mainEntry.Ref)
 
 	// 7. Test entry parsing
 	t.Log("Testing entry parsing...")
@@ -278,3 +278,275 @@ func testNormalizeCommand(t *testing.T, cmd string) string {
 
 	return normalized
 }
+
+// TestCommitQuoteNormalizationIssue reproduces the bug where git commit commands
+// with different quote patterns create duplicate log entries.
+func TestCommitQuoteNormalizationIssue(t *testing.T) {
+	t.Log("Testing commit command quote normalization issue")
+
+	// Commands that should normalize to the same thing
+	quotedCmd := `git commit -m "Add file2.txt"`
+	unquotedCmd := `git commit -m Add file2.txt`
+
+	t.Logf("Quoted command: %s", quotedCmd)
+	t.Logf("Unquoted command: %s", unquotedCmd)
+
+	// Test normalization
+	quotedNorm := testNormalizeCommand(t, quotedCmd)
+	unquotedNorm := testNormalizeCommand(t, unquotedCmd)
+
+	t.Logf("Quoted normalized: %s", quotedNorm)
+	t.Logf("Unquoted normalized: %s", unquotedNorm)
+
+	// They should normalize to the same thing
+	assert.Equal(t, quotedNorm, unquotedNorm, "Both commands should normalize to the same form")
+
+	// Test with more complex scenarios
+	testCases := []struct {
+		name     string
+		commands []string
+	}{
+		{
+			name: "Basic commit messages",
+			commands: []string{
+				`git commit -m "test message"`,
+				`git commit -m 'test message'`,
+				`git commit -m test message`,
+			},
+		},
+		{
+			name: "Messages with spaces",
+			commands: []string{
+				`git commit -m "Add file2.txt"`,
+				`git commit -m 'Add file2.txt'`,
+				`git commit -m Add file2.txt`,
+			},
+		},
+		{
+			name: "Verbose flag variations",
+			commands: []string{
+				`git commit --verbose -m "commit f2"`,
+				`git commit -m "commit f2"`,
+				`git commit -m commit f2`,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			var normalizedForms []string
+			for _, cmd := range tc.commands {
+				norm := testNormalizeCommand(t, cmd)
+				normalizedForms = append(normalizedForms, norm)
+				t.Logf("Command: %s -> Normalized: %s", cmd, norm)
+			}
+
+			// All normalized forms should be identical
+			for i := 1; i < len(normalizedForms); i++ {
+				assert.Equal(t, normalizedForms[0], normalizedForms[i],
+					"Commands should normalize to the same form")
+			}
+		})
+	}
+}
+
+// TestActualDuplicateLogging tests that deduplication actually works in practice.
+func TestActualDuplicateLogging(t *testing.T) {
+	t.Log("Testing actual duplicate logging scenario that reproduces BATS failure")
+
+	mgc := NewMockGitHelper()
+	SwitchRef(mgc, "main")
+
+	tmpDir := t.TempDir()
+	lgr := logging.NewLogger(tmpDir, mgc)
+	require.NotNil(t, lgr)
+
+	// Test the exact scenario from the BATS test output:
+	// One command has quotes, one doesn't, but they represent the same git operation
+	quotedCmd := `git commit -m "Add file2.txt"`
+	unquotedCmd := `git commit -m Add file2.txt`
+
+	t.Logf("Testing commands:")
+	t.Logf("  1. %s", quotedCmd)
+	t.Logf("  2. %s", unquotedCmd)
+
+	// Simulate different hook environments
+	oldMarker := os.Getenv("GIT_UNDO_GIT_HOOK_MARKER")
+	oldInternal := os.Getenv("GIT_UNDO_INTERNAL_HOOK")
+	oldHookName := os.Getenv("GIT_HOOK_NAME")
+	defer func() {
+		// Restore environment
+		if oldMarker != "" {
+			t.Setenv("GIT_UNDO_GIT_HOOK_MARKER", oldMarker)
+		} else {
+			os.Unsetenv("GIT_UNDO_GIT_HOOK_MARKER")
+		}
+		if oldInternal != "" {
+			t.Setenv("GIT_UNDO_INTERNAL_HOOK", oldInternal)
+		} else {
+			os.Unsetenv("GIT_UNDO_INTERNAL_HOOK")
+		}
+		if oldHookName != "" {
+			t.Setenv("GIT_HOOK_NAME", oldHookName)
+		} else {
+			os.Unsetenv("GIT_HOOK_NAME")
+		}
+	}()
+
+	// First: Git hook logs the quoted version
+	t.Setenv("GIT_UNDO_GIT_HOOK_MARKER", "1")
+	t.Setenv("GIT_UNDO_INTERNAL_HOOK", "1")
+	t.Setenv("GIT_HOOK_NAME", "post-commit")
+
+	err := lgr.LogCommand(quotedCmd)
+	require.NoError(t, err)
+
+	// Second: Shell hook logs the unquoted version
+	t.Setenv("GIT_UNDO_GIT_HOOK_MARKER", "")
+	t.Setenv("GIT_UNDO_INTERNAL_HOOK", "1")
+	t.Setenv("GIT_HOOK_NAME", "")
+
+	err = lgr.LogCommand(unquotedCmd)
+	require.NoError(t, err)
+
+	// Check log content - should have only ONE entry due to deduplication
+	var buffer bytes.Buffer
+	require.NoError(t, lgr.Dump(&buffer))
+	content := buffer.String()
+
+	t.Logf("Log content:\n%s", content)
+
+	lines := strings.Split(strings.TrimSpace(content), "\n")
+	if len(lines) == 1 && lines[0] == "" {
+		lines = []string{} // Empty file
+	}
+
+	// This test should FAIL initially, showing the bug
+	// After we fix it, this should pass
+	assert.Len(t, lines, 1, "Should have exactly 1 log entry due to deduplication, but got: %v", lines)
+
+	if len(lines) > 1 {
+		t.Logf("BUG REPRODUCED: Found %d entries when expecting 1:", len(lines))
+		for i, line := range lines {
+			t.Logf("  Entry %d: %s", i+1, line)
+		}
+	}
+}
+
+// TestGitBackToggleBehavior tests that git-back can toggle back and forth
+// between branches even after its own undoed entries.
+func TestGitBackToggleBehavior(t *testing.T) {
+	t.Log("Testing git-back toggle behavior with undoed checkout entries")
+
+	mgc := NewMockGitHelper()
+	SwitchRef(mgc, "another-branch")
+
+	tmpDir := t.TempDir()
+	lgr := logging.NewLogger(tmpDir, mgc)
+	require.NotNil(t, lgr)
+
+	// Simulate the exact scenario from the failing BATS test:
+	// Start on another-branch, simulate multiple git-back calls that mark checkouts as undoed
+
+	// 1. First checkout to feature-branch
+	err := lgr.LogCommand("git checkout feature-branch")
+	require.NoError(t, err)
+	SwitchRef(mgc, "feature-branch")
+
+	// 2. git-back call 1: Find and mark the checkout as undoed
+	entry1, err := lgr.GetLastCheckoutSwitchEntry(logging.RefAny)
+	require.NoError(t, err)
+	require.NotNil(t, entry1)
+	assert.Equal(t, "git checkout feature-branch", entry1.Command)
+
+	err = lgr.ToggleEntry(entry1.GetIdentifier())
+	require.NoError(t, err)
+	SwitchRef(mgc, "another-branch")
+
+	// 3. Checkout to main
+	err = lgr.LogCommand("git checkout main")
+	require.NoError(t, err)
+	SwitchRef(mgc, "main")
+
+	// 4. git-back call 2: Should find the checkout to main and mark it as undoed
+	entry2, err := lgr.GetLastCheckoutSwitchEntry(logging.RefAny)
+	require.NoError(t, err)
+	require.NotNil(t, entry2)
+	assert.Equal(t, "git checkout main", entry2.Command)
+
+	err = lgr.ToggleEntry(entry2.GetIdentifier())
+	require.NoError(t, err)
+	SwitchRef(mgc, "another-branch")
+
+	// 5. Add some other activity to make the log more complex
+	err = lgr.LogCommand("git add unstaged.txt")
+	require.NoError(t, err)
+
+	// 6. Current implementation fails
+	entry3, err := lgr.GetLastCheckoutSwitchEntry(logging.RefAny)
+	require.NoError(t, err)
+	assert.Nil(t, entry3, "Current implementation should fail to find checkout when all are undoed")
+
+	// 7. But new method should work
+	entry4, err := lgr.GetLastCheckoutSwitchEntryForToggle(logging.RefAny)
+	require.NoError(t, err)
+	assert.NotNil(t, entry4, "New method should find checkout command even if undoed")
+	if entry4 != nil {
+		t.Logf("Found checkout entry: %s (undoed: %v)", entry4.Command, entry4.Undoed)
+	}
+
+	// Check the log to see what's in there
+	var buffer bytes.Buffer
+	require.NoError(t, lgr.Dump(&buffer))
+	content := buffer.String()
+	t.Logf("Log content:\n%s", content)
+}
+
+// TestGitBackFindAnyCheckout tests that git-back can find checkout commands
+// regardless of their undoed status.
+func TestGitBackFindAnyCheckout(t *testing.T) {
+	t.Log("Testing git-back can find any checkout command for toggle behavior")
+
+	mgc := NewMockGitHelper()
+	SwitchRef(mgc, "main")
+
+	tmpDir := t.TempDir()
+	lgr := logging.NewLogger(tmpDir, mgc)
+	require.NotNil(t, lgr)
+
+	// Simple scenario: log some checkouts and test finding them
+	err := lgr.LogCommand("git checkout feature-1")
+	require.NoError(t, err)
+
+	err = lgr.LogCommand("git checkout feature-2")
+	require.NoError(t, err)
+
+	err = lgr.LogCommand("git add file.txt") // Non-checkout command
+	require.NoError(t, err)
+
+	// Test the new method can find the latest checkout
+	entry, err := lgr.GetLastCheckoutSwitchEntryForToggle(logging.RefAny)
+	require.NoError(t, err)
+	require.NotNil(t, entry)
+	assert.Equal(t, "git checkout feature-2", entry.Command)
+	assert.False(t, entry.Undoed)
+
+	// Mark it as undoed
+	err = lgr.ToggleEntry(entry.GetIdentifier())
+	require.NoError(t, err)
+
+	// Traditional method should not find it now
+	entry2, err := lgr.GetLastCheckoutSwitchEntry(logging.RefAny)
+	require.NoError(t, err)
+	require.NotNil(t, entry2)
+	assert.Equal(t, "git checkout feature-1", entry2.Command) // Should find the previous one
+
+	// But new method should still find the latest one (even though undoed)
+	entry3, err := lgr.GetLastCheckoutSwitchEntryForToggle(logging.RefAny)
+	require.NoError(t, err)
+	require.NotNil(t, entry3)
+	assert.Equal(t, "git checkout feature-2", entry3.Command)
+	assert.True(t, entry3.Undoed) // Should be marked as undoed
+
+	t.Log("✅ git-back can successfully find checkout commands for toggle behavior")
+}
diff --git a/internal/git-undo/undoer/add.go b/internal/git-undo/undoer/add.go
index 4170383..d4cbdec 100644
--- a/internal/git-undo/undoer/add.go
+++ b/internal/git-undo/undoer/add.go
@@ -14,8 +14,8 @@ type AddUndoer struct {
 
 var _ Undoer = &AddUndoer{}
 
-// GetUndoCommand returns the command that would undo the add operation.
-func (a *AddUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the add operation.
+func (a *AddUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if HEAD exists (i.e., if there are any commits)
 	// If there's no HEAD, we need to use 'git reset' instead of 'git restore --staged'
 	headExists := true
@@ -38,9 +38,9 @@ func (a *AddUndoer) GetUndoCommand() (*UndoCommand, error) {
 	// If --all flag was used or no specific files, unstage everything
 	if hasAllFlag || len(a.originalCmd.Args) == 0 {
 		if headExists {
-			return NewUndoCommand(a.git, "git restore --staged .", "Unstage all files"), nil
+			return []*UndoCommand{NewUndoCommand(a.git, "git restore --staged .", "Unstage all files")}, nil
 		}
-		return NewUndoCommand(a.git, "git reset", "Unstage all files"), nil
+		return []*UndoCommand{NewUndoCommand(a.git, "git reset", "Unstage all files")}, nil
 	}
 
 	// For other cases, filter out flags and only pass real file paths to restore
@@ -55,22 +55,22 @@ func (a *AddUndoer) GetUndoCommand() (*UndoCommand, error) {
 	// If we only had flags but no files, default to restoring everything
 	if len(filesToRestore) == 0 {
 		if headExists {
-			return NewUndoCommand(a.git, "git restore --staged .", "Unstage all files"), nil
+			return []*UndoCommand{NewUndoCommand(a.git, "git restore --staged .", "Unstage all files")}, nil
 		}
 
-		return NewUndoCommand(a.git, "git reset", "Unstage all files"), nil
+		return []*UndoCommand{NewUndoCommand(a.git, "git reset", "Unstage all files")}, nil
 	}
 
 	if headExists {
-		return NewUndoCommand(
+		return []*UndoCommand{NewUndoCommand(
 			a.git,
 			fmt.Sprintf("git restore --staged %s", strings.Join(filesToRestore, " ")),
 			fmt.Sprintf("Unstage specific files: %s", strings.Join(filesToRestore, ", ")),
-		), nil
+		)}, nil
 	}
-	return NewUndoCommand(
+	return []*UndoCommand{NewUndoCommand(
 		a.git,
 		fmt.Sprintf("git reset %s", strings.Join(filesToRestore, " ")),
 		fmt.Sprintf("Unstage specific files: %s", strings.Join(filesToRestore, ", ")),
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/branch.go b/internal/git-undo/undoer/branch.go
index 40e043f..10c94fc 100644
--- a/internal/git-undo/undoer/branch.go
+++ b/internal/git-undo/undoer/branch.go
@@ -11,8 +11,8 @@ type BranchUndoer struct {
 	originalCmd *CommandDetails
 }
 
-// GetUndoCommand returns the command that would undo the branch creation.
-func (b *BranchUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the branch creation.
+func (b *BranchUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a branch deletion operation
 	for _, arg := range b.originalCmd.Args {
 		if arg == "-d" || arg == "-D" || arg == "--delete" {
@@ -25,8 +25,8 @@ func (b *BranchUndoer) GetUndoCommand() (*UndoCommand, error) {
 		return nil, fmt.Errorf("no branch name found in command: %s", b.originalCmd.FullCommand)
 	}
 
-	return NewUndoCommand(b.git,
+	return []*UndoCommand{NewUndoCommand(b.git,
 		fmt.Sprintf("git branch -D %s", branchName),
 		fmt.Sprintf("Delete branch '%s'", branchName),
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/checkout.go b/internal/git-undo/undoer/checkout.go
index 8e1518f..7fd074e 100644
--- a/internal/git-undo/undoer/checkout.go
+++ b/internal/git-undo/undoer/checkout.go
@@ -11,16 +11,16 @@ type CheckoutUndoer struct {
 	originalCmd *CommandDetails
 }
 
-// GetUndoCommand returns the command that would undo the checkout operation.
-func (c *CheckoutUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the checkout operation.
+func (c *CheckoutUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Handle checkout -b as branch creation
 	for i, arg := range c.originalCmd.Args {
 		if (arg == "-b" || arg == "--branch") && i+1 < len(c.originalCmd.Args) {
 			branchName := c.originalCmd.Args[i+1]
-			return NewUndoCommand(c.git,
+			return []*UndoCommand{NewUndoCommand(c.git,
 				fmt.Sprintf("git branch -D %s", branchName),
 				fmt.Sprintf("Delete branch '%s' created by checkout -b", branchName),
-			), nil
+			)}, nil
 		}
 	}
 
diff --git a/internal/git-undo/undoer/cherry_pick.go b/internal/git-undo/undoer/cherry_pick.go
index a152e83..94877c3 100644
--- a/internal/git-undo/undoer/cherry_pick.go
+++ b/internal/git-undo/undoer/cherry_pick.go
@@ -15,8 +15,8 @@ type CherryPickUndoer struct {
 
 var _ Undoer = &CherryPickUndoer{}
 
-// GetUndoCommand returns the command that would undo the cherry-pick operation.
-func (c *CherryPickUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the cherry-pick operation.
+func (c *CherryPickUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a cherry-pick with --no-commit flag
 	noCommit := false
 	for _, arg := range c.originalCmd.Args {
@@ -29,10 +29,10 @@ func (c *CherryPickUndoer) GetUndoCommand() (*UndoCommand, error) {
 	if noCommit {
 		// If --no-commit was used, the cherry-pick changes are staged but not committed
 		// We undo by resetting the index
-		return NewUndoCommand(c.git,
+		return []*UndoCommand{NewUndoCommand(c.git,
 			"git reset --mixed HEAD",
 			"Reset staged cherry-pick changes",
-		), nil
+		)}, nil
 	}
 
 	// For committed cherry-picks, we need to remove the cherry-pick commit
@@ -52,23 +52,30 @@ func (c *CherryPickUndoer) GetUndoCommand() (*UndoCommand, error) {
 
 	if cherryPickHead != "" {
 		// We're in the middle of a cherry-pick (probably due to conflicts)
-		return NewUndoCommand(c.git,
+		return []*UndoCommand{NewUndoCommand(c.git,
 			"git cherry-pick --abort",
 			"Abort ongoing cherry-pick operation",
-		), nil
+		)}, nil
 	}
 
-	// Validate that the current commit looks like it could be a cherry-pick
-	// Check reflog to see if the last operation was cherry-pick
+	// Since we know the original command was cherry-pick (stored in originalCmd),
+	// we can trust this information. However, we still need to validate the current state
+	// to ensure we can safely undo the operation.
+
+	// For safety, check if HEAD has changed since the cherry-pick
+	// If the repo state looks consistent with a cherry-pick, proceed
 	reflogOutput, err := c.git.GitOutput("reflog", "-1", "--format=%s")
 	if err == nil {
 		reflogMsg := strings.TrimSpace(reflogOutput)
-		if !strings.Contains(reflogMsg, "cherry-pick") {
-			// Be more permissive - check if the commit message indicates cherry-pick
+		// Accept cherry-pick, merge (fast-forward), or commit operations
+		// These are all valid outcomes of a cherry-pick command
+		if !strings.Contains(reflogMsg, "cherry-pick") &&
+			!strings.Contains(reflogMsg, "merge") &&
+			!strings.Contains(reflogMsg, "commit") {
+			// As a final check, see if commit message indicates cherry-pick
 			commitMsg, err := c.git.GitOutput("log", "-1", "--format=%s", "HEAD")
 			if err == nil {
 				commitMsg = strings.TrimSpace(commitMsg)
-				// Cherry-picked commits often have (cherry picked from commit ...) suffix
 				if !strings.Contains(commitMsg, "cherry picked from commit") {
 					return nil, errors.New("current HEAD does not appear to be a cherry-pick commit")
 				}
@@ -89,22 +96,22 @@ func (c *CherryPickUndoer) GetUndoCommand() (*UndoCommand, error) {
 	// Check for staged changes
 	stagedOutput, err := c.git.GitOutput("diff", "--cached", "--name-only")
 	if err == nil && strings.TrimSpace(stagedOutput) != "" {
-		warnings = append(warnings, "This will preserve staged changes")
+		warnings = append(warnings, "Warning: This will discard staged changes")
 	}
 
 	// Check for unstaged changes
 	unstagedOutput, err := c.git.GitOutput("diff", "--name-only")
 	if err == nil && strings.TrimSpace(unstagedOutput) != "" {
-		warnings = append(warnings, "This will preserve unstaged changes")
+		warnings = append(warnings, "Warning: This will discard unstaged changes")
 	}
 
-	// Use soft reset to preserve working directory and staging area
-	undoCommand := fmt.Sprintf("git reset --soft %s", parentCommit)
+	// Use hard reset to completely remove the cherry-picked changes
+	undoCommand := fmt.Sprintf("git reset --hard %s", parentCommit)
 
 	// Safely truncate commit hash
 	shortHash := getShortHash(currentHead)
 
 	description := fmt.Sprintf("Remove cherry-pick commit %s", shortHash)
 
-	return NewUndoCommand(c.git, undoCommand, description, warnings...), nil
+	return []*UndoCommand{NewUndoCommand(c.git, undoCommand, description, warnings...)}, nil
 }
diff --git a/internal/git-undo/undoer/cherry_pick_test.go b/internal/git-undo/undoer/cherry_pick_test.go
index 323f6f8..83eeefc 100644
--- a/internal/git-undo/undoer/cherry_pick_test.go
+++ b/internal/git-undo/undoer/cherry_pick_test.go
@@ -30,7 +30,7 @@ func TestCherryPickUndoer_GetUndoCommand(t *testing.T) {
 				m.On("GitOutput", "diff", "--cached", "--name-only").Return("", nil)
 				m.On("GitOutput", "diff", "--name-only").Return("", nil)
 			},
-			expectedCmd:  "git reset --soft xyz789",
+			expectedCmd:  "git reset --hard xyz789",
 			expectedDesc: "Remove cherry-pick commit def456",
 			expectError:  false,
 		},
@@ -53,13 +53,44 @@ func TestCherryPickUndoer_GetUndoCommand(t *testing.T) {
 			expectedDesc: "Abort ongoing cherry-pick operation",
 			expectError:  false,
 		},
+		{
+			name:    "fast-forward cherry-pick (merge in reflog)",
+			command: "git cherry-pick abc123",
+			setupMock: func(m *MockGitExec) {
+				m.On("GitOutput", "rev-parse", "HEAD").Return("def456", nil)
+				m.On("GitOutput", "rev-parse", "--verify", "CHERRY_PICK_HEAD").Return("", errors.New("not found"))
+				m.On("GitOutput", "reflog", "-1", "--format=%s").Return("merge abc123", nil)
+				m.On("GitOutput", "rev-parse", "HEAD~1").Return("xyz789", nil)
+				m.On("GitOutput", "diff", "--cached", "--name-only").Return("", nil)
+				m.On("GitOutput", "diff", "--name-only").Return("", nil)
+			},
+			expectedCmd:  "git reset --hard xyz789",
+			expectedDesc: "Remove cherry-pick commit def456",
+			expectError:  false,
+		},
+		{
+			name:    "cherry-pick with commit in reflog",
+			command: "git cherry-pick abc123",
+			setupMock: func(m *MockGitExec) {
+				m.On("GitOutput", "rev-parse", "HEAD").Return("def456", nil)
+				m.On("GitOutput", "rev-parse", "--verify", "CHERRY_PICK_HEAD").Return("", errors.New("not found"))
+				m.On("GitOutput", "reflog", "-1", "--format=%s").
+					Return("commit (cherry-pick): Cherry-pick target commit", nil)
+				m.On("GitOutput", "rev-parse", "HEAD~1").Return("xyz789", nil)
+				m.On("GitOutput", "diff", "--cached", "--name-only").Return("", nil)
+				m.On("GitOutput", "diff", "--name-only").Return("", nil)
+			},
+			expectedCmd:  "git reset --hard xyz789",
+			expectedDesc: "Remove cherry-pick commit def456",
+			expectError:  false,
+		},
 		{
 			name:    "non-cherry-pick commit",
 			command: "git cherry-pick abc123",
 			setupMock: func(m *MockGitExec) {
 				m.On("GitOutput", "rev-parse", "HEAD").Return("def456", nil)
 				m.On("GitOutput", "rev-parse", "--verify", "CHERRY_PICK_HEAD").Return("", errors.New("not found"))
-				m.On("GitOutput", "reflog", "-1", "--format=%s").Return("commit: regular message", nil)
+				m.On("GitOutput", "reflog", "-1", "--format=%s").Return("rebase: regular operation", nil)
 				m.On("GitOutput", "log", "-1", "--format=%s", "HEAD").Return("Regular commit", nil)
 			},
 			expectError:   true,
@@ -77,7 +108,7 @@ func TestCherryPickUndoer_GetUndoCommand(t *testing.T) {
 
 			cherryPickUndoer := undoer.NewCherryPickUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := cherryPickUndoer.GetUndoCommand()
+			undoCmds, err := cherryPickUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -86,9 +117,9 @@ func TestCherryPickUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/clean.go b/internal/git-undo/undoer/clean.go
index 380dd4f..7e6c934 100644
--- a/internal/git-undo/undoer/clean.go
+++ b/internal/git-undo/undoer/clean.go
@@ -15,8 +15,8 @@ type CleanUndoer struct {
 
 var _ Undoer = &CleanUndoer{}
 
-// GetUndoCommand returns the command that would undo the clean operation.
-func (c *CleanUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the clean operation.
+func (c *CleanUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Git clean is inherently destructive and removes untracked files permanently.
 	// Unlike other git operations, once files are cleaned, they cannot be recovered
 	// from git's internal state since they were never tracked.
diff --git a/internal/git-undo/undoer/clean_test.go b/internal/git-undo/undoer/clean_test.go
index d21fb4d..4f8b76e 100644
--- a/internal/git-undo/undoer/clean_test.go
+++ b/internal/git-undo/undoer/clean_test.go
@@ -56,7 +56,7 @@ func TestCleanUndoer_GetUndoCommand(t *testing.T) {
 
 			cleanUndoer := undoer.NewCleanUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := cleanUndoer.GetUndoCommand()
+			undoCmds, err := cleanUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -65,9 +65,9 @@ func TestCleanUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/commit.go b/internal/git-undo/undoer/commit.go
index 5b792b1..ab01c6e 100644
--- a/internal/git-undo/undoer/commit.go
+++ b/internal/git-undo/undoer/commit.go
@@ -13,44 +13,44 @@ type CommitUndoer struct {
 	originalCmd *CommandDetails
 }
 
-// GetUndoCommand returns the command that would undo the commit.
-func (c *CommitUndoer) GetUndoCommand() (*UndoCommand, error) {
-	if err := c.git.GitRun("rev-parse", "HEAD^{commit}"); err != nil {
+// GetUndoCommands returns the commands that would undo the commit.
+func (c *CommitUndoer) GetUndoCommands() ([]*UndoCommand, error) {
+	if err := c.git.GitRun("rev-parse", "HEAD~1"); err != nil {
 		return nil, errors.New("this appears to be the initial commit and cannot be undone this way")
 	}
 
 	// Check if this is a merge commit
 	if err := c.git.GitRun("rev-parse", "-q", "--verify", "HEAD^2"); err == nil {
-		return NewUndoCommand(c.git,
+		return []*UndoCommand{NewUndoCommand(c.git,
 			"git reset --merge ORIG_HEAD",
 			"Undo merge commit by resetting to ORIG_HEAD",
-		), nil
+		)}, nil
 	}
 
 	// Get the commit message to check if it was an amended commit
 	commitMsg, err := c.git.GitOutput("log", "-1", "--pretty=%B")
 	if err == nil && strings.Contains(commitMsg, "[amend]") {
-		return NewUndoCommand(c.git,
+		return []*UndoCommand{NewUndoCommand(c.git,
 			"git reset --soft HEAD@{1}",
 			"Undo amended commit by resetting to previous HEAD",
-		), nil
+		)}, nil
 	}
 
 	// Check if the commit is tagged
 	tagOutput, err := c.git.GitOutput("tag", "--points-at", "HEAD")
 	if err == nil && tagOutput != "" {
-		return NewUndoCommand(c.git,
+		return []*UndoCommand{NewUndoCommand(c.git,
 			"git reset --soft HEAD~1",
 			"Undo commit while keeping changes staged",
 			fmt.Sprintf(
 				"Warning: The commit being undone has the following tags: %s\nThese tags will now point to the parent commit.",
 				tagOutput,
 			),
-		), nil
+		)}, nil
 	}
 
-	return NewUndoCommand(c.git,
+	return []*UndoCommand{NewUndoCommand(c.git,
 		"git reset --soft HEAD~1",
 		"Undo commit while keeping changes staged",
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/merge.go b/internal/git-undo/undoer/merge.go
index e077f9a..fdd0e07 100644
--- a/internal/git-undo/undoer/merge.go
+++ b/internal/git-undo/undoer/merge.go
@@ -14,15 +14,15 @@ type MergeUndoer struct {
 
 var _ Undoer = &MergeUndoer{}
 
-// GetUndoCommand returns the command that would undo the merge operation.
-func (m *MergeUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the merge operation.
+func (m *MergeUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a merge with conflicts
 	output, err := m.git.GitOutput("status")
 	if err == nil && strings.Contains(output, "You have unmerged paths") {
-		return NewUndoCommand(m.git,
+		return []*UndoCommand{NewUndoCommand(m.git,
 			"git merge --abort",
 			"Abort merge and restore state before merging",
-		), nil
+		)}, nil
 	}
 
 	// Check if ORIG_HEAD exists (it should for a merge)
@@ -36,16 +36,16 @@ func (m *MergeUndoer) GetUndoCommand() (*UndoCommand, error) {
 	if fastForwardMergeErr := m.git.GitRun("rev-parse", "-q", "--verify", "HEAD^2"); fastForwardMergeErr != nil {
 		// For fast-forward merges, we can just reset to ORIG_HEAD
 		//nolint:nilerr // it's OK here
-		return NewUndoCommand(m.git,
+		return []*UndoCommand{NewUndoCommand(m.git,
 			"git reset --hard ORIG_HEAD",
 			"Undo fast-forward merge by resetting to ORIG_HEAD",
-		), nil
+		)}, nil
 	}
 
 	// For true merges (with a merge commit), we use --merge flag
-	return NewUndoCommand(m.git,
+	return []*UndoCommand{NewUndoCommand(m.git,
 		"git reset --merge ORIG_HEAD",
 		"Undo merge commit by resetting to ORIG_HEAD",
 		"This will undo the merge and restore the state before merging",
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/mv.go b/internal/git-undo/undoer/mv.go
index 280fc67..3740b9d 100644
--- a/internal/git-undo/undoer/mv.go
+++ b/internal/git-undo/undoer/mv.go
@@ -14,8 +14,8 @@ type MvUndoer struct {
 
 var _ Undoer = &MvUndoer{}
 
-// GetUndoCommand returns the command that would undo the mv operation.
-func (m *MvUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the mv operation.
+func (m *MvUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Parse arguments to find source and destination
 	// git mv can be: git mv <source> <dest> or git mv <source1> <source2> ... <dest_dir>
 
@@ -41,10 +41,12 @@ func (m *MvUndoer) GetUndoCommand() (*UndoCommand, error) {
 			return nil, fmt.Errorf("destination '%s' does not exist in git index, cannot undo move", dest)
 		}
 
-		return NewUndoCommand(m.git,
-			fmt.Sprintf("git mv %s %s", dest, source),
-			fmt.Sprintf("Move '%s' back to '%s'", dest, source),
-		), nil
+		return []*UndoCommand{
+			NewUndoCommand(m.git,
+				fmt.Sprintf("git mv %s %s", dest, source),
+				fmt.Sprintf("Move '%s' back to '%s'", dest, source),
+			),
+		}, nil
 	}
 
 	// Handle multiple sources into directory: git mv <source1> <source2> ... <dest_dir>
@@ -52,9 +54,8 @@ func (m *MvUndoer) GetUndoCommand() (*UndoCommand, error) {
 	destDir := nonFlagArgs[len(nonFlagArgs)-1]
 	sources := nonFlagArgs[:len(nonFlagArgs)-1]
 
-	// Build the undo command to move all files back
-	var undoCommands []string
-	var descriptions []string
+	// Build separate undo commands for each file
+	var undoCommands []*UndoCommand
 
 	for _, source := range sources {
 		// Extract the filename from the source path
@@ -73,13 +74,13 @@ func (m *MvUndoer) GetUndoCommand() (*UndoCommand, error) {
 			return nil, fmt.Errorf("moved file '%s' does not exist in destination, cannot undo move", currentPath)
 		}
 
-		undoCommands = append(undoCommands, fmt.Sprintf("git mv %s %s", currentPath, source))
-		descriptions = append(descriptions, fmt.Sprintf("'%s' → '%s'", currentPath, source))
+		// Create individual undo command for this file
+		undoCmd := NewUndoCommand(m.git,
+			fmt.Sprintf("git mv %s %s", currentPath, source),
+			fmt.Sprintf("Move '%s' back to '%s'", currentPath, source),
+		)
+		undoCommands = append(undoCommands, undoCmd)
 	}
 
-	// Combine all undo commands
-	fullUndoCommand := strings.Join(undoCommands, " && ")
-	description := fmt.Sprintf("Move files back: %s", strings.Join(descriptions, ", "))
-
-	return NewUndoCommand(m.git, fullUndoCommand, description), nil
+	return undoCommands, nil
 }
diff --git a/internal/git-undo/undoer/mv_integration_test.go b/internal/git-undo/undoer/mv_integration_test.go
new file mode 100644
index 0000000..a5822e8
--- /dev/null
+++ b/internal/git-undo/undoer/mv_integration_test.go
@@ -0,0 +1,123 @@
+package undoer_test
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/amberpixels/git-undo/internal/git-undo/undoer"
+	"github.com/amberpixels/git-undo/internal/githelpers"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestMvUndoer_Integration_MultipleFiles tests the actual execution of multi-file mv undo
+// This replicates the bug found in BATS test "1A: Phase 1 Commands".
+func TestMvUndoer_Integration_MultipleFiles(t *testing.T) {
+	// Create a temporary directory for our git repo
+	tmpDir := t.TempDir()
+
+	// Initialize git repo
+	cmd := exec.Command("git", "init")
+	cmd.Dir = tmpDir
+	err := cmd.Run()
+	require.NoError(t, err)
+
+	// Configure git for testing
+	cmd = exec.Command("git", "config", "user.email", "test@example.com")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	cmd = exec.Command("git", "config", "user.name", "Test User")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	// Create initial commit
+	cmd = exec.Command("git", "commit", "--allow-empty", "-m", "init")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	// Create test files
+	file1Path := filepath.Join(tmpDir, "file1.txt")
+	file2Path := filepath.Join(tmpDir, "file2.txt")
+	subdirPath := filepath.Join(tmpDir, "subdir")
+
+	err = os.WriteFile(file1Path, []byte("file1 content"), 0644)
+	require.NoError(t, err)
+	err = os.WriteFile(file2Path, []byte("file2 content"), 0644)
+	require.NoError(t, err)
+
+	// Stage and commit the files
+	cmd = exec.Command("git", "add", "file1.txt", "file2.txt")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	cmd = exec.Command("git", "commit", "-m", "Add files for move test")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	// Create subdirectory
+	err = os.MkdirAll(subdirPath, 0755)
+	require.NoError(t, err)
+
+	// Move multiple files to subdirectory (this is the operation we want to undo)
+	cmd = exec.Command("git", "mv", "file1.txt", "file2.txt", "subdir/")
+	cmd.Dir = tmpDir
+	err = cmd.Run()
+	require.NoError(t, err)
+
+	// Verify files were moved
+	assert.NoFileExists(t, file1Path)
+	assert.NoFileExists(t, file2Path)
+	assert.FileExists(t, filepath.Join(subdirPath, "file1.txt"))
+	assert.FileExists(t, filepath.Join(subdirPath, "file2.txt"))
+
+	// Now test the undo operation
+	cmdDetails, err := undoer.ParseGitCommand("git mv file1.txt file2.txt subdir/")
+	require.NoError(t, err)
+
+	// Create the real GitExec (not mock)
+	realGitExec := githelpers.NewGitHelper(tmpDir)
+	mvUndoer := undoer.NewMvUndoerForTest(realGitExec, cmdDetails)
+
+	// Get the undo commands (should be multiple for multi-file mv)
+	undoCommands, err := mvUndoer.GetUndoCommands()
+	require.NoError(t, err)
+	require.NotEmpty(t, undoCommands, "Should have at least one undo command")
+
+	t.Logf("Number of undo commands: %d", len(undoCommands))
+	for i, cmd := range undoCommands {
+		t.Logf("Undo command %d: %s", i+1, cmd.Command)
+		t.Logf("Undo description %d: %s", i+1, cmd.Description)
+	}
+
+	// Execute all undo commands in sequence
+	for i, undoCmd := range undoCommands {
+		err = undoCmd.Exec()
+		if err != nil {
+			t.Logf("Undo command %d failed: %v", i+1, err)
+		}
+		require.NoError(t, err, "Undo command %d should succeed", i+1)
+	}
+
+	// Verify files are back in original location
+	assert.FileExists(t, file1Path, "file1.txt should be restored to original location")
+	assert.FileExists(t, file2Path, "file2.txt should be restored to original location")
+	assert.NoFileExists(t, filepath.Join(subdirPath, "file1.txt"), "file1.txt should not exist in subdir")
+	assert.NoFileExists(t, filepath.Join(subdirPath, "file2.txt"), "file2.txt should not exist in subdir")
+
+	// Verify file contents are preserved
+	content1, err := os.ReadFile(file1Path)
+	require.NoError(t, err)
+	assert.Equal(t, "file1 content", string(content1))
+
+	content2, err := os.ReadFile(file2Path)
+	require.NoError(t, err)
+	assert.Equal(t, "file2 content", string(content2))
+}
diff --git a/internal/git-undo/undoer/mv_test.go b/internal/git-undo/undoer/mv_test.go
index 1134ba8..dab106e 100644
--- a/internal/git-undo/undoer/mv_test.go
+++ b/internal/git-undo/undoer/mv_test.go
@@ -1,7 +1,6 @@
 package undoer_test
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/amberpixels/git-undo/internal/git-undo/undoer"
@@ -9,13 +8,13 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestMvUndoer_GetUndoCommand(t *testing.T) {
+func TestMvUndoer_GetUndoCommands(t *testing.T) {
 	tests := []struct {
 		name          string
 		command       string
 		setupMock     func(*MockGitExec)
-		expectedCmd   string
-		expectedDesc  string
+		expectedCmds  []string
+		expectedDescs []string
 		expectError   bool
 		errorContains string
 	}{
@@ -25,9 +24,9 @@ func TestMvUndoer_GetUndoCommand(t *testing.T) {
 			setupMock: func(m *MockGitExec) {
 				m.On("GitRun", "ls-files", "--error-unmatch", "new.txt").Return(nil)
 			},
-			expectedCmd:  "git mv new.txt old.txt",
-			expectedDesc: "Move 'new.txt' back to 'old.txt'",
-			expectError:  false,
+			expectedCmds:  []string{"git mv new.txt old.txt"},
+			expectedDescs: []string{"Move 'new.txt' back to 'old.txt'"},
+			expectError:   false,
 		},
 		{
 			name:    "multiple files to directory",
@@ -36,9 +35,15 @@ func TestMvUndoer_GetUndoCommand(t *testing.T) {
 				m.On("GitRun", "ls-files", "--error-unmatch", "src/file1.txt").Return(nil)
 				m.On("GitRun", "ls-files", "--error-unmatch", "src/file2.txt").Return(nil)
 			},
-			expectedCmd:  "git mv src/file1.txt file1.txt && git mv src/file2.txt file2.txt",
-			expectedDesc: "Move files back: 'src/file1.txt' → 'file1.txt', 'src/file2.txt' → 'file2.txt'",
-			expectError:  false,
+			expectedCmds: []string{
+				"git mv src/file1.txt file1.txt",
+				"git mv src/file2.txt file2.txt",
+			},
+			expectedDescs: []string{
+				"Move 'src/file1.txt' back to 'file1.txt'",
+				"Move 'src/file2.txt' back to 'file2.txt'",
+			},
+			expectError: false,
 		},
 		{
 			name:          "insufficient arguments",
@@ -47,15 +52,6 @@ func TestMvUndoer_GetUndoCommand(t *testing.T) {
 			expectError:   true,
 			errorContains: "insufficient arguments",
 		},
-		{
-			name:    "destination doesn't exist",
-			command: "git mv old.txt new.txt",
-			setupMock: func(m *MockGitExec) {
-				m.On("GitRun", "ls-files", "--error-unmatch", "new.txt").Return(errors.New("file not found"))
-			},
-			expectError:   true,
-			errorContains: "does not exist in git index",
-		},
 	}
 
 	for _, tt := range tests {
@@ -68,7 +64,7 @@ func TestMvUndoer_GetUndoCommand(t *testing.T) {
 
 			mvUndoer := undoer.NewMvUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := mvUndoer.GetUndoCommand()
+			undoCmds, err := mvUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -77,9 +73,11 @@ func TestMvUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, len(tt.expectedCmds))
+				for i, cmd := range undoCmds {
+					assert.Equal(t, tt.expectedCmds[i], cmd.Command)
+					assert.Equal(t, tt.expectedDescs[i], cmd.Description)
+				}
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/reset.go b/internal/git-undo/undoer/reset.go
index cefad04..ba5909e 100644
--- a/internal/git-undo/undoer/reset.go
+++ b/internal/git-undo/undoer/reset.go
@@ -15,10 +15,10 @@ type ResetUndoer struct {
 
 var _ Undoer = &ResetUndoer{}
 
-// GetUndoCommand returns the command that would undo the reset operation.
+// GetUndoCommands returns the commands that would undo the reset operation.
 //
 //nolint:goconst // we're having lot of string git commands here
-func (r *ResetUndoer) GetUndoCommand() (*UndoCommand, error) {
+func (r *ResetUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// First, get the current HEAD to know where we are now
 	//TODO: do we actually need HEAD here?
 	_, err := r.git.GitOutput("rev-parse", "HEAD")
@@ -90,7 +90,7 @@ func (r *ResetUndoer) GetUndoCommand() (*UndoCommand, error) {
 		return nil, fmt.Errorf("%w: unsupported reset mode: %s", ErrUndoNotSupported, resetMode)
 	}
 
-	return NewUndoCommand(r.git, undoCommand, description, warnings...), nil
+	return []*UndoCommand{NewUndoCommand(r.git, undoCommand, description, warnings...)}, nil
 }
 
 // getResetMode determines the reset mode from the original command arguments.
diff --git a/internal/git-undo/undoer/reset_test.go b/internal/git-undo/undoer/reset_test.go
index a5a6f0a..c3703cc 100644
--- a/internal/git-undo/undoer/reset_test.go
+++ b/internal/git-undo/undoer/reset_test.go
@@ -90,7 +90,7 @@ func TestResetUndoer_GetUndoCommand(t *testing.T) {
 
 			resetUndoer := undoer.NewResetUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := resetUndoer.GetUndoCommand()
+			undoCmds, err := resetUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -99,11 +99,11 @@ func TestResetUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 				if tt.expectWarnings {
-					assert.NotEmpty(t, undoCmd.Warnings)
+					assert.NotEmpty(t, undoCmds[0].Warnings)
 				}
 			}
 
diff --git a/internal/git-undo/undoer/restore.go b/internal/git-undo/undoer/restore.go
index 6638f48..1790d12 100644
--- a/internal/git-undo/undoer/restore.go
+++ b/internal/git-undo/undoer/restore.go
@@ -14,8 +14,8 @@ type RestoreUndoer struct {
 
 var _ Undoer = &RestoreUndoer{}
 
-// GetUndoCommand returns the command that would undo the restore operation.
-func (r *RestoreUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the restore operation.
+func (r *RestoreUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Parse flags to understand what was restored
 	var isStaged bool
 	var isWorktree bool
@@ -75,10 +75,10 @@ func (r *RestoreUndoer) GetUndoCommand() (*UndoCommand, error) {
 	if isStaged && !isWorktree {
 		// Only --staged was used: files were unstaged from index
 		// Undo: re-add the files to staging area
-		return NewUndoCommand(r.git,
+		return []*UndoCommand{NewUndoCommand(r.git,
 			fmt.Sprintf("git add %s", strings.Join(files, " ")),
 			fmt.Sprintf("Re-stage files: %s", strings.Join(files, ", ")),
-		), nil
+		)}, nil
 	}
 
 	if isWorktree {
@@ -92,11 +92,11 @@ func (r *RestoreUndoer) GetUndoCommand() (*UndoCommand, error) {
 		warnings = append(warnings, "Consider using 'git stash' before 'git restore' in the future")
 		warnings = append(warnings, "You may be able to recover using 'git reflog' or your editor's history")
 
-		return NewUndoCommand(r.git,
+		return []*UndoCommand{NewUndoCommand(r.git,
 			"echo 'Cannot automatically undo git restore --worktree'",
 			"Cannot undo working tree restoration",
 			warnings...,
-		), fmt.Errorf("%w: cannot undo git restore --worktree (previous working tree state unknown)", ErrUndoNotSupported)
+		)}, fmt.Errorf("%w: cannot undo git restore --worktree (previous working tree state unknown)", ErrUndoNotSupported)
 	}
 
 	// Should not reach here, but just in case
diff --git a/internal/git-undo/undoer/restore_test.go b/internal/git-undo/undoer/restore_test.go
index cfa9735..3a81fe8 100644
--- a/internal/git-undo/undoer/restore_test.go
+++ b/internal/git-undo/undoer/restore_test.go
@@ -59,7 +59,7 @@ func TestRestoreUndoer_GetUndoCommand(t *testing.T) {
 
 			restoreUndoer := undoer.NewRestoreUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := restoreUndoer.GetUndoCommand()
+			undoCmds, err := restoreUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -68,9 +68,9 @@ func TestRestoreUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/revert.go b/internal/git-undo/undoer/revert.go
index 6a03f1f..29369fa 100644
--- a/internal/git-undo/undoer/revert.go
+++ b/internal/git-undo/undoer/revert.go
@@ -15,8 +15,8 @@ type RevertUndoer struct {
 
 var _ Undoer = &RevertUndoer{}
 
-// GetUndoCommand returns the command that would undo the revert operation.
-func (r *RevertUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the revert operation.
+func (r *RevertUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a revert with --no-commit flag
 	noCommit := false
 	for _, arg := range r.originalCmd.Args {
@@ -29,10 +29,10 @@ func (r *RevertUndoer) GetUndoCommand() (*UndoCommand, error) {
 	if noCommit {
 		// If --no-commit was used, the revert changes are staged but not committed
 		// We undo by resetting the index
-		return NewUndoCommand(r.git,
+		return []*UndoCommand{NewUndoCommand(r.git,
 			"git reset --mixed HEAD",
 			"Reset staged revert changes",
-		), nil
+		)}, nil
 	}
 
 	// For committed reverts, we need to identify the revert commit and remove it
@@ -76,21 +76,21 @@ func (r *RevertUndoer) GetUndoCommand() (*UndoCommand, error) {
 	// Check for staged changes
 	stagedOutput, err := r.git.GitOutput("diff", "--cached", "--name-only")
 	if err == nil && strings.TrimSpace(stagedOutput) != "" {
-		warnings = append(warnings, "This will preserve staged changes")
+		warnings = append(warnings, "Warning: This will discard staged changes")
 	}
 
 	// Check for unstaged changes
 	unstagedOutput, err := r.git.GitOutput("diff", "--name-only")
 	if err == nil && strings.TrimSpace(unstagedOutput) != "" {
-		warnings = append(warnings, "This will preserve unstaged changes")
+		warnings = append(warnings, "Warning: This will discard unstaged changes")
 	}
 
-	// Use soft reset to preserve working directory and staging area
-	undoCommand := fmt.Sprintf("git reset --soft %s", parentCommit)
+	// Use hard reset to restore both commit state and working directory
+	undoCommand := fmt.Sprintf("git reset --hard %s", parentCommit)
 
 	// Safely truncate commit hash
 	shortHash := getShortHash(currentHead)
 	description := fmt.Sprintf("Remove revert commit %s", shortHash)
 
-	return NewUndoCommand(r.git, undoCommand, description, warnings...), nil
+	return []*UndoCommand{NewUndoCommand(r.git, undoCommand, description, warnings...)}, nil
 }
diff --git a/internal/git-undo/undoer/revert_test.go b/internal/git-undo/undoer/revert_test.go
index 3e1e919..bff393f 100644
--- a/internal/git-undo/undoer/revert_test.go
+++ b/internal/git-undo/undoer/revert_test.go
@@ -29,7 +29,7 @@ func TestRevertUndoer_GetUndoCommand(t *testing.T) {
 				m.On("GitOutput", "diff", "--cached", "--name-only").Return("", nil)
 				m.On("GitOutput", "diff", "--name-only").Return("", nil)
 			},
-			expectedCmd:  "git reset --soft abc123",
+			expectedCmd:  "git reset --hard abc123",
 			expectedDesc: "Remove revert commit def456",
 			expectError:  false,
 		},
@@ -75,7 +75,7 @@ func TestRevertUndoer_GetUndoCommand(t *testing.T) {
 
 			revertUndoer := undoer.NewRevertUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := revertUndoer.GetUndoCommand()
+			undoCmds, err := revertUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -84,9 +84,9 @@ func TestRevertUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/rm.go b/internal/git-undo/undoer/rm.go
index f638342..bed1ffa 100644
--- a/internal/git-undo/undoer/rm.go
+++ b/internal/git-undo/undoer/rm.go
@@ -15,8 +15,8 @@ type RmUndoer struct {
 
 var _ Undoer = &RmUndoer{}
 
-// GetUndoCommand returns the command that would undo the rm operation.
-func (r *RmUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the rm operation.
+func (r *RmUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Parse flags to understand what type of removal was done
 	var isCachedOnly bool
 	var isRecursive bool
@@ -61,10 +61,10 @@ func (r *RmUndoer) GetUndoCommand() (*UndoCommand, error) {
 	if isCachedOnly {
 		// git rm --cached only removes from index, files still exist in working directory
 		// Undo: re-add the files to the index
-		return NewUndoCommand(r.git,
+		return []*UndoCommand{NewUndoCommand(r.git,
 			fmt.Sprintf("git add %s", strings.Join(files, " ")),
 			fmt.Sprintf("Re-add files to index: %s", strings.Join(files, ", ")),
-		), nil
+		)}, nil
 	}
 
 	// For regular git rm (removes from both index and working directory)
@@ -86,9 +86,9 @@ func (r *RmUndoer) GetUndoCommand() (*UndoCommand, error) {
 	}
 
 	// Use git restore to bring back both working tree and staged versions
-	return NewUndoCommand(r.git,
+	return []*UndoCommand{NewUndoCommand(r.git,
 		fmt.Sprintf("git restore --source=HEAD --staged --worktree %s", strings.Join(files, " ")),
 		fmt.Sprintf("Restore removed files: %s", strings.Join(files, ", ")),
 		warnings...,
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/rm_test.go b/internal/git-undo/undoer/rm_test.go
index cdce8f6..7974428 100644
--- a/internal/git-undo/undoer/rm_test.go
+++ b/internal/git-undo/undoer/rm_test.go
@@ -75,7 +75,7 @@ func TestRmUndoer_GetUndoCommand(t *testing.T) {
 
 			rmUndoer := undoer.NewRmUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := rmUndoer.GetUndoCommand()
+			undoCmds, err := rmUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -84,9 +84,9 @@ func TestRmUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/stash.go b/internal/git-undo/undoer/stash.go
index 2a3518c..66648ab 100644
--- a/internal/git-undo/undoer/stash.go
+++ b/internal/git-undo/undoer/stash.go
@@ -15,8 +15,8 @@ type StashUndoer struct {
 
 var _ Undoer = &StashUndoer{}
 
-// GetUndoCommand returns the command that would undo the stash operation.
-func (s *StashUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the stash operation.
+func (s *StashUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a stash pop/apply operation
 	for _, arg := range s.originalCmd.Args {
 		if arg == "pop" || arg == "apply" {
@@ -32,8 +32,8 @@ func (s *StashUndoer) GetUndoCommand() (*UndoCommand, error) {
 	}
 
 	// Pop the most recent stash and drop it
-	return NewUndoCommand(s.git,
+	return []*UndoCommand{NewUndoCommand(s.git,
 		"git stash pop && git stash drop",
 		"Pop the most recent stash and remove it",
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/switch.go b/internal/git-undo/undoer/switch.go
index 4dc95df..1d456ff 100644
--- a/internal/git-undo/undoer/switch.go
+++ b/internal/git-undo/undoer/switch.go
@@ -14,27 +14,27 @@ type SwitchUndoer struct {
 
 var _ Undoer = &SwitchUndoer{}
 
-// GetUndoCommand returns the command that would undo the switch operation.
-func (s *SwitchUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the switch operation.
+func (s *SwitchUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Handle switch -c as branch creation (similar to checkout -b)
 	for i, arg := range s.originalCmd.Args {
 		if (arg == "-c" || arg == "--create") && i+1 < len(s.originalCmd.Args) {
 			branchName := s.originalCmd.Args[i+1]
-			return NewUndoCommand(s.git,
+			return []*UndoCommand{NewUndoCommand(s.git,
 				fmt.Sprintf("git branch -D %s", branchName),
 				fmt.Sprintf("Delete branch '%s' created by switch -c", branchName),
-			), nil
+			)}, nil
 		}
 		// Handle switch -C as force branch creation (overwrites existing branch)
 		if (arg == "-C" || arg == "--force-create") && i+1 < len(s.originalCmd.Args) {
 			branchName := s.originalCmd.Args[i+1]
 			// For force create, we can't easily restore the previous branch state
 			// so we provide a warning and delete the branch
-			return NewUndoCommand(s.git,
+			return []*UndoCommand{NewUndoCommand(s.git,
 				fmt.Sprintf("git branch -D %s", branchName),
 				fmt.Sprintf("Delete branch '%s' created by switch -C", branchName),
 				"Warning: switch -C may have overwritten an existing branch that cannot be restored",
-			), nil
+			)}, nil
 		}
 	}
 
@@ -84,9 +84,9 @@ func (s *SwitchUndoer) GetUndoCommand() (*UndoCommand, error) {
 
 	// Use "git switch -" to go back to the previous branch
 	// git switch supports the same "-" syntax as git checkout
-	return NewUndoCommand(s.git,
+	return []*UndoCommand{NewUndoCommand(s.git,
 		"git switch -",
 		fmt.Sprintf("Switch back to previous branch (%s)", prevBranch),
 		warnings...,
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/switch_test.go b/internal/git-undo/undoer/switch_test.go
index 0544538..00bf5a0 100644
--- a/internal/git-undo/undoer/switch_test.go
+++ b/internal/git-undo/undoer/switch_test.go
@@ -125,7 +125,7 @@ func TestSwitchUndoer_GetUndoCommand(t *testing.T) {
 
 			switchUndoer := undoer.NewSwitchUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := switchUndoer.GetUndoCommand()
+			undoCmds, err := switchUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -134,11 +134,11 @@ func TestSwitchUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 				if tt.expectWarnings {
-					assert.NotEmpty(t, undoCmd.Warnings)
+					assert.NotEmpty(t, undoCmds[0].Warnings)
 				}
 			}
 
diff --git a/internal/git-undo/undoer/tag.go b/internal/git-undo/undoer/tag.go
index 512d15f..dea232c 100644
--- a/internal/git-undo/undoer/tag.go
+++ b/internal/git-undo/undoer/tag.go
@@ -14,8 +14,8 @@ type TagUndoer struct {
 
 var _ Undoer = &TagUndoer{}
 
-// GetUndoCommand returns the command that would undo the tag creation.
-func (t *TagUndoer) GetUndoCommand() (*UndoCommand, error) {
+// GetUndoCommands returns the commands that would undo the tag creation.
+func (t *TagUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// Check if this was a tag deletion operation
 	for _, arg := range t.originalCmd.Args {
 		if arg == "-d" || arg == "-D" || arg == "--delete" {
@@ -69,8 +69,8 @@ func (t *TagUndoer) GetUndoCommand() (*UndoCommand, error) {
 		return nil, fmt.Errorf("tag '%s' does not exist, cannot undo tag creation", tagName)
 	}
 
-	return NewUndoCommand(t.git,
+	return []*UndoCommand{NewUndoCommand(t.git,
 		fmt.Sprintf("git tag -d %s", tagName),
 		fmt.Sprintf("Delete tag '%s'", tagName),
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/tag_test.go b/internal/git-undo/undoer/tag_test.go
index 62aea58..ff03601 100644
--- a/internal/git-undo/undoer/tag_test.go
+++ b/internal/git-undo/undoer/tag_test.go
@@ -74,7 +74,7 @@ func TestTagUndoer_GetUndoCommand(t *testing.T) {
 
 			tagUndoer := undoer.NewTagUndoerForTest(mockGit, cmdDetails)
 
-			undoCmd, err := tagUndoer.GetUndoCommand()
+			undoCmds, err := tagUndoer.GetUndoCommands()
 
 			if tt.expectError {
 				require.Error(t, err)
@@ -83,9 +83,9 @@ func TestTagUndoer_GetUndoCommand(t *testing.T) {
 				}
 			} else {
 				require.NoError(t, err)
-				assert.NotNil(t, undoCmd)
-				assert.Equal(t, tt.expectedCmd, undoCmd.Command)
-				assert.Equal(t, tt.expectedDesc, undoCmd.Description)
+				require.Len(t, undoCmds, 1)
+				assert.Equal(t, tt.expectedCmd, undoCmds[0].Command)
+				assert.Equal(t, tt.expectedDesc, undoCmds[0].Description)
 			}
 
 			mockGit.AssertExpectations(t)
diff --git a/internal/git-undo/undoer/undo_command.go b/internal/git-undo/undoer/undoer.go
similarity index 79%
rename from internal/git-undo/undoer/undo_command.go
rename to internal/git-undo/undoer/undoer.go
index bdeb580..d8982de 100644
--- a/internal/git-undo/undoer/undo_command.go
+++ b/internal/git-undo/undoer/undoer.go
@@ -8,6 +8,14 @@ import (
 	"github.com/amberpixels/git-undo/internal/githelpers"
 )
 
+// Undoer represents an interface for undoing git commands.
+type Undoer interface {
+	// GetUndoCommands returns the commands that would undo the operation
+	// Some operations may require multiple git commands to undo properly
+	GetUndoCommands() ([]*UndoCommand, error)
+}
+
+// GitExec represents an interface for executing git commands.
 type GitExec interface {
 	GitRun(subCmd string, args ...string) error
 	GitOutput(subCmd string, args ...string) (string, error)
@@ -27,6 +35,7 @@ type UndoCommand struct {
 	git GitExec
 }
 
+// NewUndoCommand creates a new UndoCommand instance.
 func NewUndoCommand(git GitExec, cmdStr string, description string, warnings ...string) *UndoCommand {
 	return &UndoCommand{
 		Command:     cmdStr,
@@ -46,12 +55,6 @@ func (cmd *UndoCommand) Exec() error {
 	return cmd.git.GitRun(gitCmd.SubCommand, gitCmd.Args...)
 }
 
-// Undoer represents an interface for undoing git commands.
-type Undoer interface {
-	// GetUndoCommand returns the command that would undo the operation
-	GetUndoCommand() (*UndoCommand, error)
-}
-
 // CommandDetails represents parsed git command details.
 type CommandDetails struct {
 	FullCommand string   // git commit -m "message"
@@ -69,37 +72,6 @@ func (d *CommandDetails) getFirstNonFlagArg() string {
 	return ""
 }
 
-// parseGitCommand parses a git command string into a CommandDetails struct.
-func parseGitCommand(gitCmdStr string) (*CommandDetails, error) {
-	parsed, err := githelpers.ParseGitCommand(gitCmdStr)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse input git command: %w", err)
-	}
-	if !parsed.Supported {
-		return nil, fmt.Errorf("unsupported git command format: %s", gitCmdStr)
-	}
-
-	return &CommandDetails{
-		FullCommand: gitCmdStr,
-		Command:     "git",
-		SubCommand:  parsed.Name,
-		Args:        parsed.Args,
-	}, nil
-}
-
-// InvalidUndoer represents an undoer for commands that cannot be parsed or are not supported.
-type InvalidUndoer struct {
-	rawCommand string
-	parseError error
-}
-
-func (i *InvalidUndoer) GetUndoCommand() (*UndoCommand, error) {
-	if i.parseError != nil {
-		return nil, fmt.Errorf("%w: %w", ErrUndoNotSupported, i.parseError)
-	}
-	return nil, fmt.Errorf("%w: %s", ErrUndoNotSupported, i.rawCommand)
-}
-
 // New returns the appropriate Undoer implementation for a git command.
 func New(cmdStr string, gitExec GitExec) Undoer {
 	cmdDetails, err := parseGitCommand(cmdStr)
@@ -143,17 +115,20 @@ func New(cmdStr string, gitExec GitExec) Undoer {
 	}
 }
 
-// NewBack returns the appropriate Undoer implementation for git-back (checkout/switch undo).
-func NewBack(cmdStr string, gitExec GitExec) Undoer {
-	cmdDetails, err := parseGitCommand(cmdStr)
+// parseGitCommand parses a git command string into a CommandDetails struct.
+func parseGitCommand(gitCmdStr string) (*CommandDetails, error) {
+	parsed, err := githelpers.ParseGitCommand(gitCmdStr)
 	if err != nil {
-		return &InvalidUndoer{rawCommand: cmdStr, parseError: err}
+		return nil, fmt.Errorf("failed to parse input git command: %w", err)
 	}
-
-	switch cmdDetails.SubCommand {
-	case "checkout", "switch":
-		return &BackUndoer{originalCmd: cmdDetails, git: gitExec}
-	default:
-		return &InvalidUndoer{rawCommand: cmdStr}
+	if !parsed.Supported {
+		return nil, fmt.Errorf("unsupported git command format: %s", gitCmdStr)
 	}
+
+	return &CommandDetails{
+		FullCommand: gitCmdStr,
+		Command:     "git",
+		SubCommand:  parsed.Name,
+		Args:        parsed.Args,
+	}, nil
 }
diff --git a/internal/git-undo/undoer/back.go b/internal/git-undo/undoer/undoer_back.go
similarity index 77%
rename from internal/git-undo/undoer/back.go
rename to internal/git-undo/undoer/undoer_back.go
index 3b9d05c..c6ad79a 100644
--- a/internal/git-undo/undoer/back.go
+++ b/internal/git-undo/undoer/undoer_back.go
@@ -12,8 +12,23 @@ type BackUndoer struct {
 	originalCmd *CommandDetails
 }
 
-// GetUndoCommand returns the command that would undo the checkout/switch operation.
-func (b *BackUndoer) GetUndoCommand() (*UndoCommand, error) {
+// NewBack returns the appropriate Undoer implementation for git-back (checkout/switch undo).
+func NewBack(cmdStr string, gitExec GitExec) Undoer {
+	cmdDetails, err := parseGitCommand(cmdStr)
+	if err != nil {
+		return &InvalidUndoer{rawCommand: cmdStr, parseError: err}
+	}
+
+	switch cmdDetails.SubCommand {
+	case "checkout", "switch":
+		return &BackUndoer{originalCmd: cmdDetails, git: gitExec}
+	default:
+		return &InvalidUndoer{rawCommand: cmdStr}
+	}
+}
+
+// GetUndoCommands returns the commands that would undo the checkout/switch operation.
+func (b *BackUndoer) GetUndoCommands() ([]*UndoCommand, error) {
 	// For git-back, we want to go back to the previous branch
 	// We can use "git checkout -" which switches to the previous branch
 
@@ -33,7 +48,7 @@ func (b *BackUndoer) GetUndoCommand() (*UndoCommand, error) {
 	_ = prevBranch // TODO: fixme.. do we need prevBranch at all?
 
 	// Check working directory status to detect potential conflicts
-	warnings := []string{}
+	var warnings []string
 
 	// Check for staged changes
 	stagedOutput, err := b.git.GitOutput("diff", "--cached", "--name-only")
@@ -60,9 +75,9 @@ func (b *BackUndoer) GetUndoCommand() (*UndoCommand, error) {
 	}
 
 	// Use "git checkout -" to go back to the previous branch/commit
-	return NewUndoCommand(b.git,
+	return []*UndoCommand{NewUndoCommand(b.git,
 		"git checkout -",
 		"Switch back to previous branch/commit",
 		warnings...,
-	), nil
+	)}, nil
 }
diff --git a/internal/git-undo/undoer/undoer_invalid.go b/internal/git-undo/undoer/undoer_invalid.go
new file mode 100644
index 0000000..ca0ed2e
--- /dev/null
+++ b/internal/git-undo/undoer/undoer_invalid.go
@@ -0,0 +1,18 @@
+package undoer
+
+import "fmt"
+
+// InvalidUndoer represents an undoer for commands that cannot be parsed or are not supported.
+type InvalidUndoer struct {
+	rawCommand string
+	parseError error
+}
+
+// GetUndoCommands implements the Undoer interface.
+func (i *InvalidUndoer) GetUndoCommands() ([]*UndoCommand, error) {
+	if i.parseError != nil {
+		return nil, fmt.Errorf("%w: %w", ErrUndoNotSupported, i.parseError)
+	}
+
+	return nil, fmt.Errorf("%w: %s", ErrUndoNotSupported, i.rawCommand)
+}
diff --git a/internal/githelpers/gitcommand.go b/internal/githelpers/gitcommand.go
index 6674ae2..6eed09a 100644
--- a/internal/githelpers/gitcommand.go
+++ b/internal/githelpers/gitcommand.go
@@ -168,7 +168,7 @@ type argsNormalizer func([]string) ([]string, error)
 var (
 	// normalizeCommitArgs normalizes commit command arguments to canonical form.
 	normalizeCommitArgs = func(args []string) ([]string, error) {
-		message := ""
+		var messageParts []string
 		amend := false
 
 		n := len(args)
@@ -181,17 +181,31 @@ var (
 			arg := args[i]
 			switch {
 			case arg == "-m" && i+1 < n:
-				// Extract message, removing quotes
-				message = strings.Trim(args[i+1], `"'`)
+				// Collect all arguments after -m that don't start with - as the message
+				// This handles both quoted and unquoted commit messages
+				for j := i + 1; j < n; j++ {
+					nextArg := args[j]
+					if strings.HasPrefix(nextArg, "-") {
+						break // Stop at next flag
+					}
+					// Remove quotes and add to message parts
+					cleanPart := strings.Trim(nextArg, `"'`)
+					messageParts = append(messageParts, cleanPart)
+				}
 
-				//nolint:ineffassign // We're fine with this
-				i++ // Skip the message argument
+				// Skip all the message arguments we just processed
+				j := i + 1
+				for j < n && !strings.HasPrefix(args[j], "-") {
+					j++
+				}
+				i = j - 1 //nolint:ineffassign,staticcheck // Skip processed arguments in the range loop
 			case arg == "--amend":
 				amend = true
 			case strings.HasPrefix(arg, "-m"):
 				// Handle -m"message" format
 				if len(arg) > 2 {
-					message = strings.Trim(arg[2:], `"'`)
+					cleanMsg := strings.Trim(arg[2:], `"'`)
+					messageParts = append(messageParts, cleanMsg)
 				}
 				// Ignore other flags like --verbose, --signoff, etc.
 			}
@@ -201,7 +215,9 @@ var (
 		var result []string
 		if amend {
 			result = append(result, "--amend")
-		} else if message != "" {
+		} else if len(messageParts) > 0 {
+			// Join all message parts with spaces to create the full message
+			message := strings.Join(messageParts, " ")
 			result = append(result, "-m", message)
 		}
 
diff --git a/internal/testutil/suite.go b/internal/testutil/suite.go
index 99617d7..af741c5 100644
--- a/internal/testutil/suite.go
+++ b/internal/testutil/suite.go
@@ -32,6 +32,12 @@ func (s *GitTestSuite) SetupSuite() {
 
 	// Initialize git repository
 	s.RunCmd("git", "init", ".")
+
+	// Disable git hooks during testing to avoid conflicts with simulated hooks
+	// Create a local hooks directory that's empty
+	localHooksDir := filepath.Join(s.repoDir, ".git", "hooks")
+	s.RunCmd("git", "config", "core.hooksPath", localHooksDir)
+
 	s.RunCmd("git", "commit", "--allow-empty", "-m", "init")
 }
 
diff --git a/scripts/integration/integration-test.bats b/scripts/integration/integration-test.bats
index 3f6b577..65d4a66 100644
--- a/scripts/integration/integration-test.bats
+++ b/scripts/integration/integration-test.bats
@@ -4,6 +4,76 @@
 load 'test_helper/bats-support/load'
 load 'test_helper/bats-assert/load'
 
+# Helper function for verbose command execution
+# Usage: run_verbose <command> [args...]
+# Shows command output with boxing for multi-line content
+run_verbose() {
+    run "$@"
+    local cmd_str="$1"
+    shift
+    while [[ $# -gt 0 ]]; do
+        cmd_str="$cmd_str $1"
+        shift
+    done
+    
+    if [[ $status -eq 0 ]]; then
+        if [[ -n "$output" ]]; then
+            # Check if output has multiple lines or is long
+            local line_count=$(echo "$output" | wc -l)
+            local char_count=${#output}
+            if [[ $line_count -gt 1 ]] || [[ $char_count -gt 80 ]]; then
+                echo ""
+                echo -e "\033[95m┌─ $cmd_str ─\033[0m"
+                echo -e "\033[95m$output\033[0m"
+                echo -e "\033[95m└────────────\033[0m"
+            else
+                echo -e "\033[32m>\033[0m $cmd_str: $output"
+            fi
+        else
+            echo -e "\033[32m>\033[0m $cmd_str: (no output)"
+        fi
+    else
+        echo ""
+        echo -e "\033[95m┌─ $cmd_str (FAILED: status $status) ─\033[0m"
+        echo -e "\033[95m$output\033[0m"
+        echo -e "\033[95m└────────────\033[0m"
+    fi
+}
+
+# Helper function for commands that should only show output on failure
+# Usage: run_quiet <command> [args...]
+# Only shows output if command fails
+run_quiet() {
+    run "$@"
+    if [[ $status -ne 0 ]]; then
+        local cmd_str="$1"
+        shift
+        while [[ $# -gt 0 ]]; do
+            cmd_str="$cmd_str $1"
+            shift
+        done
+        echo "> $cmd_str FAILED: $output (status: $status)"
+    fi
+}
+
+# Helper function for colored output
+# Usage: print <message> - prints in cyan
+# Usage: debug <message> - prints in gray  
+# Usage: title <message> - prints in yellow
+print() {
+    echo -e "\033[96m> $*\033[0m"  # Cyan
+}
+
+debug() {
+    echo -e "\033[90m> DEBUG: $*\033[0m"  # Gray
+}
+
+title() {
+    echo -e "\033[93m================================================================================"
+    echo -e "\033[93m $*\033[0m"  # Yellow
+    echo -e "\033[93m================================================================================\033[0m"
+}
+
 setup() {
     # Create isolated test repository for the test
     export TEST_REPO="$(mktemp -d)"
@@ -13,6 +83,13 @@ setup() {
     git config user.email "git-undo-test@amberpixels.io"
     git config user.name "Git-Undo Integration Test User"
     
+    # Configure git hooks for this repository
+    git config core.hooksPath ~/.config/git-undo/hooks
+    
+    # Source hooks in the test shell environment
+    # shellcheck disable=SC1090
+    source ~/.config/git-undo/git-undo-hook.bash
+    
     # Create initial empty commit so we always have HEAD (like in unit tests)
     git commit --allow-empty -m "init"
 }
@@ -22,11 +99,11 @@ teardown() {
     rm -rf "$TEST_REPO"
 }
 
-@test "complete git-undo integration workflow" {
+@test "0A: complete git-undo integration workflow" {
     # ============================================================================
-    # PHASE 1: Verify Installation
+    # PHASE 0A-1: Verify Installation
     # ============================================================================
-    echo "# Phase 1: Verifying git-undo installation..."
+    title "Phase 0A-1: Verifying git-undo installation..."
     
     run which git-undo
     assert_success
@@ -40,58 +117,54 @@ teardown() {
     # ============================================================================
     # HOOK DIAGNOSTICS: Debug hook installation and activation
     # ============================================================================
-    echo "# HOOK DIAGNOSTICS: Checking hook installation..."
+    title "HOOK DIAGNOSTICS: Checking hook installation..."
     
     # Check if hook files exist
-    echo "# Checking if hook files exist in ~/.config/git-undo/..."
+    echo "> Checking if hook files exist in ~/.config/git-undo/..."
     run ls -la ~/.config/git-undo/
     assert_success
-    echo "# Hook directory contents: ${output}"
+    echo "> Hook directory contents: ${output}"
     
     # Verify hook files are present
     assert [ -f ~/.config/git-undo/git-undo-hook.bash ]
-    echo "# ✓ Hook file exists: ~/.config/git-undo/git-undo-hook.bash"
+    echo "> ✓ Hook file exists: ~/.config/git-undo/git-undo-hook.bash"
     
     # Verify that the test hook is actually installed (should contain git function)
-    echo "# Checking if test hook is installed (contains git function)..."
+    echo "> Checking if test hook is installed (contains git function)..."
     run grep -q "git()" ~/.config/git-undo/git-undo-hook.bash
     assert_success
-    echo "# ✓ Test hook confirmed: contains git function"
+    echo "> ✓ Test hook confirmed: contains git function"
     
     # Check if .bashrc has the source line
-    echo "# Checking if .bashrc contains git-undo source line..."
+    echo "> Checking if .bashrc contains git-undo source line..."
     run grep -n git-undo ~/.bashrc
     assert_success
-    echo "# .bashrc git-undo lines: ${output}"
+    echo "> .bashrc git-undo lines: ${output}"
     
     # Check current git command type (before sourcing hooks)
-    echo "# Checking git command type before hook loading..."
+    echo "> Checking git command type before hook loading..."
     run type git
-    echo "# Git type before: ${output}"
+    echo "> Git type before: ${output}"
     
-    # Manually source the hook to test if it works
-    echo "# Manually sourcing git-undo hook..."
-    source ~/.config/git-undo/git-undo-hook.bash
-    
-    # Check git command type after sourcing hooks
-    echo "# Checking git command type after hook loading..."
+    # Check git command type (hooks are sourced in setup)
+    echo "> Checking git command type after hook loading..."
     run type git
-    echo "# Git type after: ${output}"
+    echo "> Git type after: ${output}"
     
     # Test if git-undo function/alias is available
-    echo "# Testing if git undo command is available..."
+    echo "> Testing if git undo command is available..."
     run git undo --help
     if [[ $status -eq 0 ]]; then
-        echo "# ✓ git undo command responds"
+        echo "> ✓ git undo command responds"
     else
-        echo "# ✗ git undo command failed with status: $status"
-        echo "# Output: ${output}"
+        echo "> ✗ git undo command failed with status: $status"
+        echo "> Output: ${output}"
     fi
     
     # ============================================================================
-    # PHASE 2: Basic git add and undo workflow
+    # PHASE 0A-2: Basic git add and undo workflow
     # ============================================================================
-    echo "# Phase 2: Testing basic git add and undo..."
+    title "Phase 0A-2: Testing basic git add and undo..."
     
     # Create test files
     echo "content of file1" > file1.txt
@@ -99,7 +172,7 @@ teardown() {
     echo "content of file3" > file3.txt
     
     # Verify files are untracked initially
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "?? file1.txt"
     assert_output --partial "?? file2.txt"
@@ -107,47 +180,45 @@ teardown() {
     
     # Add first file
     git add file1.txt
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "A  file1.txt"
     assert_output --partial "?? file2.txt"
-    
+    assert_output --partial "?? file3.txt"
+
     # Add second file
     git add file2.txt
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "A  file1.txt"
     assert_output --partial "A  file2.txt"
     assert_output --partial "?? file3.txt"
     
     # First undo - should unstage file2.txt
-    echo "# DEBUG: Checking git-undo log before first undo..."
-    run git undo --log
+    debug "Checking git-undo log before first undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
     
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "A  file1.txt"
     assert_output --partial "?? file2.txt"
     assert_output --partial "?? file3.txt"
-    refute_output --partial "A  file2.txt"
-    
+
     # Second undo - should unstage file1.txt
-    echo "# DEBUG: Checking git-undo log before second undo..."
-    run git undo --log
+    debug "Checking git-undo log before second undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
     
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "?? file1.txt"
     assert_output --partial "?? file2.txt"
@@ -156,21 +227,21 @@ teardown() {
     refute_output --partial "A  file2.txt"
     
     # ============================================================================
-    # PHASE 3: Commit and undo workflow
+    # PHASE 0A-3: Commit and undo workflow
     # ============================================================================
-    echo "# Phase 3: Testing commit and undo..."
+    title "Phase 0A-3: Testing commit and undo..."
     
     # Stage and commit first file
     git add file1.txt
     git commit -m "Add file1.txt"
     
     # Verify clean working directory (except for untracked files from previous phase)
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "?? file2.txt"
     assert_output --partial "?? file3.txt"
     refute_output --partial "file1.txt"  # file1.txt should be committed, not in status
-    
+
     # Verify file1 exists and is committed
     assert [ -f "file1.txt" ]
     
@@ -179,23 +250,22 @@ teardown() {
     git commit -m "Add file2.txt"
     
     # Verify clean working directory again (only file3.txt should remain untracked)
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "?? file3.txt"
     refute_output --partial "file1.txt"  # file1.txt should be committed
     refute_output --partial "file2.txt"  # file2.txt should be committed
     
     # First commit undo - should undo last commit, leaving file2 staged
-    echo "# DEBUG: Checking git-undo log before commit undo..."
-    run git undo --log
+    debug "Checking git-undo log before commit undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
-    
+
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "A  file2.txt"
     
@@ -204,25 +274,24 @@ teardown() {
     assert [ -f "file2.txt" ]
     
     # Second undo - should unstage file2.txt  
-    echo "# DEBUG: Checking git-undo log before second commit undo..."
-    run git undo --log
+    debug "Checking git-undo log before second commit undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
-    
+
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "?? file2.txt"
     assert_output --partial "?? file3.txt"
     refute_output --partial "A  file2.txt"
     
     # ============================================================================
-    # PHASE 4: Complex sequential workflow
+    # PHASE 0A-4: Complex sequential workflow
     # ============================================================================
-    echo "# Phase 4: Testing complex sequential operations..."
+    title "Phase 0A-4: Testing complex sequential operations..."
     
     # Commit file3
     git add file3.txt
@@ -233,7 +302,7 @@ teardown() {
     git add file1.txt
     
     # Verify modified file1 is staged
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "M  file1.txt"
     
@@ -242,38 +311,36 @@ teardown() {
     git add file4.txt
     
     # Verify both staged
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "M  file1.txt"
     assert_output --partial "A  file4.txt"
     
     # Undo staging of file4
-    echo "# DEBUG: Checking git-undo log before file4 undo..."
-    run git undo --log
+    debug "Checking git-undo log before file4 undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
     
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "M  file1.txt"  # file1 still staged
     assert_output --partial "?? file4.txt"  # file4 unstaged
     refute_output --partial "A  file4.txt"
     
     # Undo staging of modified file1
-    echo "# DEBUG: Checking git-undo log before modified file1 undo..."
-    run git undo --log
+    debug "Checking git-undo log before modified file1 undo..."
+    run_verbose git undo --log
     assert_success
     refute_output ""  # Log should not be empty if hooks are tracking
-    echo "# Log output: ${output}"
     
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial " M file1.txt"  # Modified but unstaged
     assert_output --partial "?? file4.txt"
@@ -283,16 +350,16 @@ teardown() {
     run git undo
     assert_success
     
-    run git status --porcelain
+    run_verbose git status --porcelain
     assert_success
     assert_output --partial "A  file3.txt"  # file3 back to staged
     assert_output --partial " M file1.txt"  # file1 still modified
     assert_output --partial "?? file4.txt"
     
     # ============================================================================
-    # PHASE 5: Verification of final state
+    # PHASE 0A-5: Verification of final state
     # ============================================================================
-    echo "# Phase 5: Final state verification..."
+    title "Phase 0A-5: Final state verification..."
     
     # Verify all files exist
     assert [ -f "file1.txt" ]
@@ -307,14 +374,14 @@ teardown() {
     refute_output --partial "Add file2.txt"
     refute_output --partial "Add file3.txt"
     
-    echo "# Integration test completed successfully!"
+    print "Integration test completed successfully!"
 }
 
-@test "git-back integration test - checkout and switch undo" {
+@test "0B: git-back integration test - checkout and switch undo" {
     # ============================================================================
-    # PHASE 1: Verify git-back Installation
+    # PHASE 0B-1: Verify git-back Installation
     # ============================================================================
-    echo "# Phase 1: Verifying git-back installation..."
+    title "Phase 0B-1: Verifying git-back installation..."
     
     run which git-back
     assert_success
@@ -331,9 +398,9 @@ teardown() {
     assert_output --partial "Git-back undoes the last git checkout or git switch command"
     
     # ============================================================================
-    # PHASE 2: Basic branch switching workflow
+    # PHASE 0B-2: Basic branch switching workflow
     # ============================================================================
-    echo "# Phase 2: Testing basic branch switching..."
+    title "Phase 0B-2: Testing basic branch switching..."
     
     # Create and commit some files to establish a proper git history
     echo "main content" > main.txt
@@ -356,19 +423,11 @@ teardown() {
     run git branch --show-current
     assert_success
     assert_output "another-branch"
-    
-    # ============================================================================
-    # PHASE 3: Source hooks for git-back tracking
-    # ============================================================================
-    echo "# Phase 3: Setting up hooks for git-back tracking..."
-    
-    # Source the hook to enable command tracking
-    source ~/.config/git-undo/git-undo-hook.bash
-    
+
     # ============================================================================
-    # PHASE 4: Test git-back with checkout commands
+    # PHASE 0B-3: Test git-back with checkout commands
     # ============================================================================
-    echo "# Phase 4: Testing git-back with checkout..."
+    title "Phase 0B-3: Testing git-back with checkout..."
     
     # Switch to feature branch (this should be tracked)
     git checkout feature-branch
@@ -379,7 +438,7 @@ teardown() {
     assert_output "feature-branch"
     
     # Use git-back to go back to previous branch (should be another-branch)
-    run git-back
+    run_verbose git back
     assert_success
     
     # Verify we're back on another-branch
@@ -388,9 +447,9 @@ teardown() {
     assert_output "another-branch"
     
     # ============================================================================
-    # PHASE 5: Test multiple branch switches
+    # PHASE 0B-4: Test multiple branch switches
     # ============================================================================
-    echo "# Phase 5: Testing multiple branch switches..."
+    title "Phase 0B-4: Testing multiple branch switches..."
     
     # Switch to main branch
     git checkout main
@@ -401,7 +460,7 @@ teardown() {
     assert_output "main"
     
     # Use git-back to go back to previous branch (should be another-branch)
-    run git-back
+    run_verbose git back
     assert_success
     
     # Verify we're back on another-branch
@@ -411,9 +470,14 @@ teardown() {
     
     # Switch to feature-branch again
     git checkout feature-branch
+
+    debug "Checking git-undo log before modified file1 undo..."
+    run_verbose git undo --log
+    assert_success
+    refute_output ""  # Log should not be empty if hooks are tracking
     
     # Use git-back to go back to another-branch
-    run git-back
+    run_verbose git back
     assert_success
     
     # Verify we're on another-branch
@@ -422,9 +486,9 @@ teardown() {
     assert_output "another-branch"
     
     # ============================================================================
-    # PHASE 6: Test git-back with uncommitted changes (should show warnings)
+    # PHASE 0B-5: Test git-back with uncommitted changes (should show warnings)
     # ============================================================================
-    echo "# Phase 6: Testing git-back with uncommitted changes..."
+    title "Phase 0B-5: Testing git-back with uncommitted changes..."
     
     # Make some uncommitted changes
     echo "modified content" >> another.txt
@@ -432,9 +496,12 @@ teardown() {
     
     # Stage one file
     git add unstaged.txt
-    
+
+    # Now try git-back in verbose mode to see warnings
+    run_verbose git undo --log
+
     # Now try git-back in verbose mode to see warnings
-    run git-back -v
+    run_verbose git back -v
     # Note: This might fail due to conflicts, but we want to verify warnings are shown
     # The important thing is that warnings are displayed to the user
     
@@ -442,7 +509,7 @@ teardown() {
     git stash
     
     # Now git-back should work
-    run git-back
+    run_verbose git back
     assert_success
     
     # Verify we're back on feature-branch
@@ -450,16 +517,14 @@ teardown() {
     assert_success
     assert_output "feature-branch"
     
-    # Pop the stash to restore our changes
-    git stash pop
-    
-    echo "# git-back integration test completed successfully!"
+    print "git-back integration test completed successfully!"
 }
 
-@test "Phase 1 Commands: git rm, mv, tag, restore undo functionality" {
-    echo "# ============================================================================"
-    echo "# PHASE 1 COMMANDS TEST: Testing git rm, mv, tag, restore undo functionality"
-    echo "# ============================================================================"
+@test "1A: Phase 1A Commands: git rm, mv, tag, restore undo functionality" {
+    title "Phase 1A-1: Testing git rm, mv, tag, restore undo functionality"
+
+    run_verbose git status --porcelain
+    assert_success
     
     # Setup: Create some initial commits so we're not trying to undo the initial commit
     echo "initial content" > initial.txt
@@ -471,9 +536,9 @@ teardown() {
     git commit -m "Second commit"
     
     # ============================================================================
-    # PHASE 1A: Test git tag undo
+    # PHASE 1A-2: Test git tag undo
     # ============================================================================
-    echo "# Phase 1A: Testing git tag undo..."
+    title "Phase 1A-2: Testing git tag undo..."
     
     # Create a tag
     git tag v1.0.0
@@ -484,7 +549,7 @@ teardown() {
     assert_output "v1.0.0"
     
     # Undo the tag creation
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify tag is deleted
@@ -501,7 +566,7 @@ teardown() {
     assert_output "v2.0.0"
     
     # Undo the annotated tag creation
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify tag is deleted
@@ -510,9 +575,9 @@ teardown() {
     assert_output ""
     
     # ============================================================================
-    # PHASE 1B: Test git mv undo
+    # PHASE 1A-3: Test git mv undo
     # ============================================================================
-    echo "# Phase 1B: Testing git mv undo..."
+    title "Phase 1A-3: Testing git mv undo..."
     
     # Create a file to move
     echo "content for moving" > moveme.txt
@@ -527,7 +592,7 @@ teardown() {
     [ -f moved.txt ]
     
     # Undo the move
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify file is back to original name
@@ -540,30 +605,30 @@ teardown() {
     echo "file2 content" > file2.txt
     git add file1.txt file2.txt
     git commit -m "Add files for directory move"
-    
+
     # Move files to subdirectory
     git mv file1.txt file2.txt subdir/
-    
+
     # Verify files were moved
     [ ! -f file1.txt ]
     [ ! -f file2.txt ]
     [ -f subdir/file1.txt ]
     [ -f subdir/file2.txt ]
-    
+
     # Undo the move
-    run git-undo
+    run_verbose git-undo
     assert_success
-    
+
     # Verify files are back
     [ -f file1.txt ]
     [ -f file2.txt ]
     [ ! -f subdir/file1.txt ]
     [ ! -f subdir/file2.txt ]
-    
+
     # ============================================================================
-    # PHASE 1C: Test git rm undo
+    # PHASE 1A-4: Test git rm undo
     # ============================================================================
-    echo "# Phase 1C: Testing git rm undo..."
+    title "Phase 1A-4: Testing git rm undo..."
     
     # Create a file to remove
     echo "content for removal" > removeme.txt
@@ -580,7 +645,7 @@ teardown() {
     [ -f removeme.txt ]
     
     # Undo the cached removal
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify file is back in index
@@ -598,7 +663,7 @@ teardown() {
     [ ! -f removeme.txt ]
     
     # Undo the removal
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify file is restored
@@ -608,9 +673,9 @@ teardown() {
     [ -f removeme.txt ]
     
     # ============================================================================
-    # PHASE 1D: Test git restore undo (staged only)
+    # PHASE 1A-5: Test git restore undo (staged only)
     # ============================================================================
-    echo "# Phase 1D: Testing git restore --staged undo..."
+    title "Phase 1A-5: Testing git restore --staged undo..."
     
     # Create and stage a file
     echo "staged content" > staged.txt
@@ -630,7 +695,7 @@ teardown() {
     assert_output ""
     
     # Undo the restore (re-stage the file)
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify file is staged again
@@ -638,13 +703,11 @@ teardown() {
     assert_success
     assert_line "staged.txt"
     
-    echo "# Phase 1 Commands integration test completed successfully!"
+    print "Phase 1A Commands integration test completed successfully!"
 }
 
-@test "Phase 2 Commands: git reset, revert, cherry-pick undo functionality" {
-    echo "# ============================================================================"
-    echo "# PHASE 2 COMMANDS TEST: Testing git reset, revert, cherry-pick undo functionality"
-    echo "# ============================================================================"
+@test "2A: Phase 2A Commands: git reset, revert, cherry-pick undo functionality" {
+    title "Phase 2A-1: Testing git reset, revert, cherry-pick undo functionality"
     
     # Setup: Create initial commit structure for testing
     echo "initial content" > initial.txt
@@ -660,30 +723,30 @@ teardown() {
     git commit -m "Third commit"
     
     # ============================================================================
-    # PHASE 2A: Test git reset undo
+    # PHASE 2A-2: Test git reset undo
     # ============================================================================
-    echo "# Phase 2A: Testing git reset undo..."
+    title "Phase 2A-2: Testing git reset undo..."
     
     # Get current commit hash for verification
-    run git rev-parse HEAD
+    run_verbose git rev-parse HEAD
     assert_success
     third_commit="$output"
     
     # Perform a soft reset to previous commit
-    git reset --soft HEAD~1
+    run_verbose git reset --soft HEAD~1
     
     # Verify we're at the second commit with staged changes
-    run git rev-parse HEAD
+    run_verbose git rev-parse HEAD
     assert_success
     second_commit="$output"
     
     # Verify third.txt is staged
-    run git diff --cached --name-only
+    run_verbose git diff --cached --name-only
     assert_success
     assert_line "third.txt"
     
     # Undo the reset (should restore HEAD to third_commit)
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify we're back at the third commit
@@ -692,19 +755,22 @@ teardown() {
     assert_output "$third_commit"
     
     # Test mixed reset undo
-    git reset HEAD~1
+    run_verbose git reset HEAD~1
     
     # Verify second commit with unstaged changes
     run git rev-parse HEAD
     assert_success
     assert_output "$second_commit"
     
-    run git status --porcelain
+    # Debug: Check what's in the log before undo
+    run_verbose git-undo --log
+    
+    run_verbose git status --porcelain
     assert_success
-    assert_output --partial " D third.txt"
+    assert_output --partial "?? third.txt"
     
     # Undo the mixed reset
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify restoration
@@ -713,9 +779,9 @@ teardown() {
     assert_output "$third_commit"
     
     # ============================================================================
-    # PHASE 2B: Test git revert undo
+    # PHASE 2A-3: Test git revert undo
     # ============================================================================
-    echo "# Phase 2B: Testing git revert undo..."
+    title "Phase 2A-3: Testing git revert undo..."
     
     # Create a commit to revert
     echo "revert-me content" > revert-me.txt
@@ -739,9 +805,13 @@ teardown() {
     [ ! -f revert-me.txt ]
     
     # Undo the revert
-    run git-undo
+    run_verbose git-undo
     assert_success
     
+    # Debug: Check git status after undo
+    run_verbose git status --porcelain
+    run_verbose ls -la revert-me.txt || echo "File not found"
+    
     # Verify we're back to the original commit
     run git rev-parse HEAD
     assert_success
@@ -751,9 +821,9 @@ teardown() {
     [ -f revert-me.txt ]
     
     # ============================================================================
-    # PHASE 2C: Test git cherry-pick undo
+    # PHASE 2A-4: Test git cherry-pick undo
     # ============================================================================
-    echo "# Phase 2C: Testing git cherry-pick undo..."
+    title "Phase 2A-4: Testing git cherry-pick undo..."
     
     # Create a feature branch with a commit to cherry-pick
     git checkout -b feature-cherry
@@ -784,7 +854,7 @@ teardown() {
     assert_output "Cherry-pick target commit"
     
     # Undo the cherry-pick
-    run git-undo
+    run_verbose git-undo
     assert_success
     
     # Verify we're back to the original main state
@@ -796,9 +866,9 @@ teardown() {
     [ ! -f cherry.txt ]
     
     # ============================================================================
-    # PHASE 2D: Test git clean undo (expected to fail)
+    # PHASE 2A-5: Test git clean undo (expected to fail)
     # ============================================================================
-    echo "# Phase 2D: Testing git clean undo (should show unsupported error)..."
+    title "Phase 2A-5: Testing git clean undo (should show unsupported error)..."
     
     # Create untracked files
     echo "untracked1" > untracked1.txt
@@ -816,17 +886,15 @@ teardown() {
     [ ! -f untracked2.txt ]
     
     # Try to undo clean (should fail with clear error message)
-    run git-undo
+    run_verbose git-undo
     assert_failure
     assert_output --partial "permanently removes untracked files that cannot be recovered"
     
-    echo "# Phase 2 Commands integration test completed successfully!"
+    print "Phase 2A Commands integration test completed successfully!"
 }
 
-@test "git switch undo functionality" {
-    echo "# ============================================================================"
-    echo "# GIT SWITCH TEST: Testing git switch undo functionality"
-    echo "# ============================================================================"
+@test "3A: git undo checkout/switch detection - warns and suggests git back" {
+    title "Phase 3A: Checkout/Switch Detection Test: Testing that git undo warns for checkout/switch commands"
     
     # Setup: Create initial commit structure for testing
     echo "initial content" > initial.txt
@@ -838,9 +906,34 @@ teardown() {
     git commit -m "Main content commit"
     
     # ============================================================================
-    # Test git switch -c (branch creation) undo
+    # PHASE 3A-1: Test git checkout detection
+    # ============================================================================
+    title "Phase 3A-1: Testing git checkout detection..."
+    
+    # Create a test branch
+    git branch test-branch
+
+    # Perform checkout operation (should be tracked)
+    git checkout test-branch
+    
+    # Verify we're on the test branch
+    run git branch --show-current
+    assert_success
+    assert_output "test-branch"
+    
+    # Try git undo - should warn about checkout command
+    run_verbose git undo 2>&1
+    assert_success
+    assert_output --partial "can't be undone"
+    assert_output --partial "git back"
+    
+    # ============================================================================
+    # PHASE 3A-2: Test git switch -c (branch creation) - should show warning
     # ============================================================================
-    echo "# Testing git switch -c branch creation undo..."
+    title "Phase 3A-2: Testing git switch -c warning..."
+    
+    # Switch back to main first
+    git checkout main
     
     # Create a new branch using git switch -c
     git switch -c feature-switch
@@ -850,27 +943,23 @@ teardown() {
     assert_success
     assert_output "feature-switch"
     
-    # Undo the branch creation
-    run git-undo
+    # Try git undo - should warn that switch can't be undone and suggest git back
+    run_verbose git undo 2>&1
     assert_success
+    assert_output --partial "can't be undone"
+    assert_output --partial "git back"
     
-    # Verify the branch was deleted and we're back on main
+    # Verify we're still on the feature-switch branch (no actual undo happened)
     run git branch --show-current
     assert_success
-    assert_output "main"
-    
-    # Verify the feature-switch branch no longer exists
-    run git branch --list feature-switch
-    assert_success
-    assert_output ""
+    assert_output "feature-switch"
     
     # ============================================================================
-    # Test regular git switch undo (branch switching)
+    # PHASE 3A-3: Test regular git switch - should show warning
     # ============================================================================
-    echo "# Testing regular git switch undo..."
+    title "Phase 3A-3: Testing regular git switch warning..."
     
-    # Create a feature branch and switch to it
-    git switch -c test-feature
+    # Add content to feature branch
     echo "feature content" > feature.txt
     git add feature.txt
     git commit -m "Feature content"
@@ -883,47 +972,56 @@ teardown() {
     assert_success
     assert_output "main"
     
-    # Undo the switch (should go back to test-feature)
-    run git-undo
+    # Try git undo - should warn about switch command and suggest git back
+    run_verbose git undo 2>&1
     assert_success
+    assert_output --partial "can't be undone"
+    assert_output --partial "git back"
     
-    # Verify we're back on test-feature
+    # Verify we're still on main (no actual undo happened)
     run git branch --show-current
     assert_success
-    assert_output "test-feature"
+    assert_output "main"
     
     # ============================================================================
-    # Test git switch with uncommitted changes (should show warnings)
+    # PHASE 3A-4: Test that git back works as expected for switch/checkout operations
     # ============================================================================
-    echo "# Testing git switch undo with uncommitted changes..."
+    title "Phase 3A-4: Testing that git back works for switch/checkout operations..."
     
-    # Create some uncommitted changes
-    echo "modified content" >> feature.txt
-    echo "new unstaged file" > unstaged.txt
-    
-    # Switch to main (git switch should handle this)
-    git switch main
-    
-    # Try to undo the switch (should work but with warnings in verbose mode)
-    run git-undo -v
+    # Use git back to go back to the previous branch (should be feature-switch)
+    run_verbose git back
     assert_success
     
-    # Verify we're back on test-feature
+    # Verify we're back on feature-switch
     run git branch --show-current
     assert_success
-    assert_output "test-feature"
+    assert_output "feature-switch"
     
-    # Clean up uncommitted changes for next tests
-    git checkout -- feature.txt
-    rm -f unstaged.txt
+    # ============================================================================
+    # PHASE 3A-5: Test mixed commands - ensure warning only appears for switch/checkout
+    # ============================================================================
+    title "Phase 3A-5: Testing that warning only appears for switch/checkout commands..."
+    
+    # Create and stage a file
+    echo "test file" > test-file.txt
+    git add test-file.txt
+    
+    # Try git undo - should work normally (no warning about git back)
+    run_verbose git undo
+    assert_success
+    refute_output --partial "can't be undone"
+    refute_output --partial "git back"
     
-    echo "# git switch integration test completed successfully!"
+    # Verify file was unstaged
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "?? test-file.txt"
+    
+    print "Checkout/switch detection integration test completed successfully!"
 }
 
-@test "git undo checkout/switch detection - warns and suggests git back" {
-    echo "# ============================================================================"
-    echo "# CHECKOUT/SWITCH DETECTION TEST: Testing that git undo warns for checkout/switch commands"
-    echo "# ============================================================================"
+@test "4A: Additional Commands: git stash, merge, reset --hard, restore, branch undo functionality" {
+    title "Phase 4A: Testing additional git command undo functionality"
     
     # Setup: Create initial commit structure for testing
     echo "initial content" > initial.txt
@@ -934,86 +1032,277 @@ teardown() {
     git add main.txt
     git commit -m "Main content commit"
     
-    # Source the hook to enable command tracking
-    source ~/.config/git-undo/git-undo-hook.bash
+    # ============================================================================
+    # PHASE 4A-1: Test git stash undo
+    # ============================================================================
+    title "Phase 4A-1: Testing git stash undo..."
+    
+    # Create some changes to stash
+    echo "changes to stash" >> main.txt
+    echo "new unstaged file" > unstaged.txt
+    
+    # Stage one change
+    git add unstaged.txt
+    
+    # Verify we have both staged and unstaged changes
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "A  unstaged.txt"
+    assert_output --partial " M main.txt"
+    
+    # Stash the changes
+    run_verbose git stash push -m "Test stash message"
+    
+    # Verify working directory is clean
+    run_verbose git status --porcelain
+    assert_success
+    assert_output ""
+    
+    # Verify files are back to original state
+    [ ! -f unstaged.txt ]
+    run cat main.txt
+    assert_success
+    assert_output "main content"
+    
+    # Undo the stash (should restore the changes)
+    run_verbose git-undo
+    assert_success
+    
+    # Verify changes are restored
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "A  unstaged.txt"
+    assert_output --partial " M main.txt"
+    
+    # Clean up for next test
+    git reset HEAD unstaged.txt
+    git checkout -- main.txt
+    rm -f unstaged.txt
     
     # ============================================================================
-    # Test git checkout detection
+    # PHASE 4A-2: Test git reset --hard undo
     # ============================================================================
-    echo "# Testing git checkout detection..."
+    title "Phase 4A-2: Testing git reset --hard undo..."
     
-    # Create a test branch
-    git branch test-branch
+    # Create a commit to reset from
+    echo "content to be reset" > reset-test.txt
+    git add reset-test.txt
+    git commit -m "Commit to be reset with --hard"
     
-    # Perform checkout operation (should be tracked)
-    git checkout test-branch
+    # Get current commit hash
+    run git rev-parse HEAD
+    assert_success
+    current_commit="$output"
     
-    # Verify we're on the test branch
-    run git branch --show-current
+    # Create some uncommitted changes
+    echo "uncommitted changes" >> main.txt
+    echo "untracked file" > untracked.txt
+    
+    # Perform hard reset (should lose uncommitted changes)
+    git reset --hard HEAD~1
+    
+    # Verify we're at previous commit and changes are gone
+    run git rev-parse HEAD
     assert_success
-    assert_output "test-branch"
+    refute_output "$current_commit"
+    [ ! -f reset-test.txt ]
+    [ -f untracked.txt ]
     
-    # Try git undo - should warn about checkout command
-    run git undo 2>&1
+    # Undo the hard reset
+    run_verbose git-undo
     assert_success
-    assert_output --partial "can't be undone"
-    assert_output --partial "git back"
+    
+    # Verify we're back at the original commit
+    run git rev-parse HEAD
+    assert_success
+    assert_output "$current_commit"
+    [ -f reset-test.txt ]
     
     # ============================================================================
-    # Test git switch detection
+    # PHASE 4A-3: Test git merge undo (fast-forward)
     # ============================================================================
-    echo "# Testing git switch detection..."
+    title "Phase 4A-3: Testing git merge undo..."
     
-    # Switch back to main
-    git switch main
+    # Create a feature branch with commits
+    git checkout -b feature-merge
+    echo "feature change 1" > feature1.txt
+    git add feature1.txt
+    git commit -m "Feature commit 1"
     
-    # Verify we're on main
-    run git branch --show-current
+    echo "feature change 2" > feature2.txt
+    git add feature2.txt
+    git commit -m "Feature commit 2"
+    
+    # Record feature branch head
+    run git rev-parse HEAD
     assert_success
-    assert_output "main"
+    feature_head="$output"
+    
+    # Switch back to main and record state
+    git checkout main
+    run git rev-parse HEAD
+    assert_success
+    main_before_merge="$output"
+    
+    # Perform fast-forward merge
+    git merge feature-merge
     
-    # Switch to test branch again
-    git switch test-branch
+    # Verify merge was successful (should be fast-forward)
+    run git rev-parse HEAD
+    assert_success
+    assert_output "$feature_head"
+    [ -f feature1.txt ]
+    [ -f feature2.txt ]
     
-    # Try git undo - should warn about switch command
-    run git undo 2>&1
+    # Undo the merge
+    run_verbose git-undo
     assert_success
-    assert_output --partial "can't be undone"
-    assert_output --partial "git back"
+    
+    # Verify we're back to pre-merge state
+    run git rev-parse HEAD
+    assert_success
+    assert_output "$main_before_merge"
+    [ ! -f feature1.txt ]
+    [ ! -f feature2.txt ]
     
     # ============================================================================
-    # Test that git back still works normally
+    # PHASE 4A-4: Test git branch -D undo (should fail with clear error message)
     # ============================================================================
-    echo "# Verifying git back still works normally..."
+    title "Phase 4A-4: Testing git branch -D undo (should show unsupported error)..."
     
-    # Use git back to return to previous branch
-    run git back
+    # Verify feature branch still exists
+    run git branch --list feature-merge
     assert_success
+    assert_output --partial "feature-merge"
     
-    # Should be back on main
-    run git branch --show-current
+    # Delete the feature branch (use -D since it's not merged)
+    git branch -D feature-merge
+    
+    # Verify branch is deleted
+    run git branch --list feature-merge
     assert_success
-    assert_output "main"
+    assert_output ""
+    
+    # Try to undo the branch deletion (should fail with clear error message)
+    run_verbose git-undo
+    assert_failure
+    assert_output --partial "git undo not supported for branch deletion"
+    
+    print "Phase 4A: Additional commands integration test completed successfully!"
+}
+
+@test "5A: Error Conditions and Edge Cases" {
+    title "Phase 5A: Testing error conditions and edge cases"
     
     # ============================================================================
-    # Test mixed commands - ensure warning only for checkout/switch
+    # PHASE 5A-1: Test git undo with no previous commands
     # ============================================================================
-    echo "# Testing mixed commands - ensuring warning only appears for checkout/switch..."
+    title "Phase 5A-1: Testing git undo with empty log..."
     
-    # Create and stage a file
-    echo "test file" > test-warning.txt
-    git add test-warning.txt
+    # Clear any existing log by creating a fresh repository state
+    # The setup() already creates a clean state with just init commit
     
-    # Now perform git undo - should work normally (no warning)
-    run git undo
+    # Try git undo when there are no tracked commands
+    # First undo should fail because it's trying to undo the initial commit
+    run_verbose git undo
+    assert_failure
+    assert_output --partial "this appears to be the initial commit and cannot be undone this way"
+    
+    # Second undo should still fail with the same error since the initial commit is still there
+    run_verbose git undo
+    assert_failure
+    assert_output --partial "this appears to be the initial commit and cannot be undone this way"
+    
+    # ============================================================================
+    # PHASE 5A-2: Test git undo --log with empty log
+    # ============================================================================
+    title "Phase 5A-2: Testing git undo --log with empty log..."
+    
+    # Check that log shows appropriate message when empty
+    run_verbose git undo --log
     assert_success
-    refute_output --partial "can't be undone"
-    refute_output --partial "git back"
+    # Should either show empty output or a message about no commands
     
-    # Verify file was unstaged
-    run git status --porcelain
+    # ============================================================================
+    # PHASE 5A-3: Test unsupported commands
+    # ============================================================================
+    title "Phase 5A-3: Testing unsupported commands..."
+    
+    # Setup some commits first
+    echo "test content" > test.txt
+    git add test.txt
+    git commit -m "Test commit"
+    
+    # Test git rebase (should show warning/error about being unsupported)
+    git checkout -b rebase-test
+    echo "branch content" > branch.txt
+    git add branch.txt
+    git commit -m "Branch commit"
+    
+    git checkout main
+    # Attempt rebase
+    git rebase rebase-test 2>/dev/null || true
+    
+    # Try to undo rebase - should fail or warn appropriately
+    run_verbose git undo
+    # This might succeed or fail depending on implementation
+    # The important thing is it handles it gracefully
+    
+    # ============================================================================
+    # PHASE 5A-4: Test git undo after hook failures
+    # ============================================================================
+    title "Phase 5A-4: Testing behavior after hook failures..."
+    
+    # Perform a normal operation that should be tracked
+    echo "tracked content" > tracked.txt
+    git add tracked.txt
+    
+    # Verify it can be undone normally
+    run_verbose git undo
+    assert_success
+    
+    # Verify file is unstaged
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "?? tracked.txt"
+    
+    # ============================================================================
+    # PHASE 5A-5: Test concurrent operations and rapid commands
+    # ============================================================================
+    title "Phase 5A-5: Testing rapid sequential commands..."
+    
+    # Perform multiple rapid operations
+    echo "rapid1" > rapid1.txt
+    git add rapid1.txt
+    echo "rapid2" > rapid2.txt  
+    git add rapid2.txt
+    echo "rapid3" > rapid3.txt
+    git add rapid3.txt
+    
+    # Verify all operations are tracked in correct order (LIFO)
+    run_verbose git undo
+    assert_success
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "A  rapid1.txt"
+    assert_output --partial "A  rapid2.txt" 
+    assert_output --partial "?? rapid3.txt"
+    
+    run_verbose git undo
+    assert_success
+    run_verbose git status --porcelain
+    assert_success
+    assert_output --partial "A  rapid1.txt"
+    assert_output --partial "?? rapid2.txt"
+    assert_output --partial "?? rapid3.txt"
+    
+    run_verbose git undo
+    assert_success
+    run_verbose git status --porcelain
     assert_success
-    assert_output --partial "?? test-warning.txt"
+    assert_output --partial "?? rapid1.txt"
+    assert_output --partial "?? rapid2.txt"
+    assert_output --partial "?? rapid3.txt"
     
-    echo "# Checkout/switch detection integration test completed successfully!"
+    print "Phase 5A:Error conditions and edge cases test completed successfully!"
 } 
\ No newline at end of file
diff --git a/scripts/integration/setup-and-test-dev.sh b/scripts/integration/setup-and-test-dev.sh
index c761783..eb7f4d9 100644
--- a/scripts/integration/setup-and-test-dev.sh
+++ b/scripts/integration/setup-and-test-dev.sh
@@ -15,7 +15,12 @@ GOPATH_BIN="$(go env GOPATH)/bin"
 export PATH="$GOPATH_BIN:$PATH"
 # shellcheck disable=SC1090
 source ~/.bashrc
+
+# Note: Git-undo hooks will be sourced within each BATS test's setup() function
+
 cd /home/testuser
 
-echo "Running integration tests..."
-bats integration-test.bats 
\ No newline at end of file
+echo " Running integration tests..."
+echo "================================================================================"
+echo ""
+bats integration-test.bats #--filter "5A:" # <- uncomment to run a specific test
\ No newline at end of file
diff --git a/scripts/integration/setup-and-test-prod.sh b/scripts/integration/setup-and-test-prod.sh
index e4c0127..4179a06 100644
--- a/scripts/integration/setup-and-test-prod.sh
+++ b/scripts/integration/setup-and-test-prod.sh
@@ -14,5 +14,7 @@ export PATH="$GOPATH_BIN:$PATH"
 # shellcheck disable=SC1090
 source ~/.bashrc
 
+# Note: Git-undo hooks will be sourced within each BATS test's setup() function
+
 echo "Running integration tests..."
-bats integration-test.bats 
\ No newline at end of file
+bats integration-test.bats # --filter "3A:" # <- uncomment to run a specific test
\ No newline at end of file
diff --git a/test-bats/test.bats b/test-bats/test.bats
new file mode 100644
index 0000000..4ac8e9c
--- /dev/null
+++ b/test-bats/test.bats
@@ -0,0 +1,8 @@
+#\!/usr/bin/env bats
+
+@test "simple test" {
+    echo "this is a test line"
+    echo "this is another line"
+    run echo "command output"
+    echo "$output"
+}