diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1272102..8b09da7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@ Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Fixed
+- Fixed target directory lock issues on Windows inside `gitgo init` on scaffolding failures by returning to the original directory before cleanup.
+
+### Changed
+- Expanded and cleaned test suite coverage (now at 93% total coverage) across commands and utility modules with clean, uncommented test cases.
+
 ---
 
 ## [1.10.1] - 2026-07-17
diff --git a/src/pygitgo/commands/init.py b/src/pygitgo/commands/init.py
index f4b92bc..320c541 100644
--- a/src/pygitgo/commands/init.py
+++ b/src/pygitgo/commands/init.py
@@ -317,6 +317,7 @@ def init_operation(args, standalone=False):
             info(f"Next steps:\n  cd {target_dir}\n  gitgo repo\n  gitgo link <url>")
 
     except Exception as e:
+        os.chdir(orig_cwd)
         if os.path.exists(target_dir) and not os.listdir(target_dir):
             try:
                 os.rmdir(target_dir)
diff --git a/src/pygitgo/utils/banner.py b/src/pygitgo/utils/banner.py
index 7fba05c..438f7a9 100644
--- a/src/pygitgo/utils/banner.py
+++ b/src/pygitgo/utils/banner.py
@@ -34,7 +34,6 @@ def _format_sync():
     return f"{YELLOW}{ahead} ahead, {behind} behind (diverged){RESET}"
 
 def show_banner():
-    # Import here to avoid circular dependencies
     from pygitgo.main import get_version
 
     ensure_inside_git_repository()
diff --git a/tests/test_banner.py b/tests/test_banner.py
new file mode 100644
index 0000000..394a6cd
--- /dev/null
+++ b/tests/test_banner.py
@@ -0,0 +1,169 @@
+from pygitgo.utils.banner import _safe, _format_sync, show_banner
+import pytest
+
+
+def test_safe_success():
+    def mock_fn():
+        return "success"
+    assert _safe(mock_fn, default="default") == "success"
+
+def test_safe_exception():
+    def mock_fn():
+        raise ValueError("error")
+    assert _safe(mock_fn, default="default") == "default"
+
+def test_format_sync_exception(mocker):
+    mocker.patch("pygitgo.utils.banner.run_command", side_effect=Exception("error"))
+    assert _format_sync() is None
+
+def test_format_sync_invalid_output(mocker):
+    mocker.patch("pygitgo.utils.banner.run_command", return_value="only_one_part")
+    assert _format_sync() is None
+    
+    mocker.patch("pygitgo.utils.banner.run_command", return_value="three parts here")
+    assert _format_sync() is None
+
+@pytest.mark.parametrize("ahead,behind,expected", [
+    (0, 0, "up to date"),
+    (2, 0, "2 ahead"),
+    (0, 3, "3 behind"),
+    (2, 3, "2 ahead, 3 behind (diverged)"),
+])
+def test_format_sync_valid_cases(mocker, ahead, behind, expected):
+    mocker.patch("pygitgo.utils.banner.run_command", return_value=f"{ahead}\t{behind}")
+    res = _format_sync()
+    assert expected in res
+
+def test_show_banner_clean_status(mocker, capsys):
+    mocker.patch("pygitgo.main.get_version", return_value="1.10.1")
+    mocker.patch("pygitgo.utils.banner.ensure_inside_git_repository")
+    mocker.patch("pygitgo.utils.banner.get_user", return_value=("Huerte", "huerte@example.com"))
+    mocker.patch("pygitgo.utils.banner.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.utils.banner.check_for_updates", return_value=None)
+    
+    def mock_run(args, *a, **k):
+        cmd_str = " ".join(args) if isinstance(args, list) else str(args)
+        if "remote.origin.url" in cmd_str:
+            return "https://github.com/Huerte/GitGo.git"
+        elif "status" in cmd_str:
+            return ""
+        elif "rev-list" in cmd_str:
+            return "0\t0"
+        return ""
+    
+    mocker.patch("pygitgo.utils.banner.run_command", side_effect=mock_run)
+    
+    mock_commits = [{"hash": "abcdef0", "message": "Initial commit", "date": "2026-07-17", "author": "Huerte"}]
+    mocker.patch("pygitgo.utils.banner.get_recent_commits", return_value=mock_commits)
+    
+    import os
+    mocker.patch("shutil.get_terminal_size", return_value=os.terminal_size((80, 20)))
+    
+    show_banner()
+    
+    captured = capsys.readouterr().out
+    assert "GitGo 1.10.1" in captured
+    assert "Your Fast Git Companion" in captured
+    assert "Identity" in captured
+    assert "Huerte <huerte@example.com>" in captured
+    assert "Remote" in captured
+    assert "https://github.com/Huerte/GitGo.git" in captured
+    assert "Branch" in captured
+    assert "main" in captured
+    assert "Sync" in captured
+    assert "up to date" in captured
+    assert "Status" in captured
+    assert "clean" in captured
+    assert "Latest" in captured
+    assert "[abcdef0] Initial commit" in captured
+
+def test_show_banner_dirty_status(mocker, capsys):
+    mocker.patch("pygitgo.main.get_version", return_value="1.10.1")
+    mocker.patch("pygitgo.utils.banner.ensure_inside_git_repository")
+    mocker.patch("pygitgo.utils.banner.get_user", return_value=(None, None))
+    mocker.patch("pygitgo.utils.banner.get_current_branch", side_effect=Exception("no branch"))
+    mocker.patch("pygitgo.utils.banner.check_for_updates", return_value="Update available: 1.10.2")
+    
+    def mock_run(args, *a, **k):
+        cmd_str = " ".join(args) if isinstance(args, list) else str(args)
+        if "remote.origin.url" in cmd_str:
+            raise Exception("no remote")
+        elif "status" in cmd_str:
+            return "M  src/main.py\n?? test.py\n"
+        elif "rev-list" in cmd_str:
+            return "2\t3"
+        return ""
+    
+    mocker.patch("pygitgo.utils.banner.run_command", side_effect=mock_run)
+    mocker.patch("pygitgo.utils.banner.get_recent_commits", return_value=[])
+    import os
+    mocker.patch("shutil.get_terminal_size", return_value=os.terminal_size((40, 20)))
+    
+    show_banner()
+    
+    captured = capsys.readouterr().out
+    assert "Identity" in captured
+    assert "Not set <Not set>" in captured
+    assert "Remote" in captured
+    assert "not set" in captured
+    assert "Branch" in captured
+    assert "unknown" in captured
+    assert "Sync" in captured
+    assert "2 ahead, 3 behind (diverged)" in captured
+    assert "Status" in captured
+    assert "1 modified, 1 untracked" in captured
+    assert "Latest" in captured
+    assert "no commits yet" in captured
+    assert "Update available: 1.10.2" in captured
+
+def test_show_banner_dirty_only_modified(mocker, capsys):
+    mocker.patch("pygitgo.main.get_version", return_value="1.10.1")
+    mocker.patch("pygitgo.utils.banner.ensure_inside_git_repository")
+    mocker.patch("pygitgo.utils.banner.get_user", return_value=("user", "email"))
+    mocker.patch("pygitgo.utils.banner.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.utils.banner.check_for_updates", return_value=None)
+    
+    def mock_run(args, *a, **k):
+        cmd_str = " ".join(args) if isinstance(args, list) else str(args)
+        if "remote.origin.url" in cmd_str:
+            return "https://github.com/Huerte/GitGo.git"
+        elif "status" in cmd_str:
+            return "M  src/main.py\n"
+        elif "rev-list" in cmd_str:
+            return "0\t0"
+        return ""
+    
+    mocker.patch("pygitgo.utils.banner.run_command", side_effect=mock_run)
+    mocker.patch("pygitgo.utils.banner.get_recent_commits", return_value=[])
+    
+    show_banner()
+    
+    captured = capsys.readouterr().out
+    assert "1 modified" in captured
+    assert "untracked" not in captured
+
+def test_show_banner_dirty_only_untracked(mocker, capsys):
+    mocker.patch("pygitgo.main.get_version", return_value="1.10.1")
+    mocker.patch("pygitgo.utils.banner.ensure_inside_git_repository")
+    mocker.patch("pygitgo.utils.banner.get_user", return_value=("user", "email"))
+    mocker.patch("pygitgo.utils.banner.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.utils.banner.check_for_updates", return_value=None)
+    
+    def mock_run(args, *a, **k):
+        cmd_str = " ".join(args) if isinstance(args, list) else str(args)
+        if "remote.origin.url" in cmd_str:
+            return "https://github.com/Huerte/GitGo.git"
+        elif "status" in cmd_str:
+            return "?? untracked.py\n"
+        elif "rev-list" in cmd_str:
+            return "0\t0"
+        return ""
+    
+    mocker.patch("pygitgo.utils.banner.run_command", side_effect=mock_run)
+    mocker.patch("pygitgo.utils.banner.get_recent_commits", return_value=[])
+    
+    show_banner()
+    
+    captured = capsys.readouterr().out
+    assert "1 untracked" in captured
+    assert "modified" not in captured
diff --git a/tests/test_colors.py b/tests/test_colors.py
new file mode 100644
index 0000000..bd17988
--- /dev/null
+++ b/tests/test_colors.py
@@ -0,0 +1,140 @@
+from pygitgo.utils.colors import _supports_color
+import pygitgo.utils.colors
+import importlib
+import pytest
+import sys
+import os
+
+@pytest.fixture(autouse=True)
+def restore_colors_after_tests():
+    yield
+    importlib.reload(pygitgo.utils.colors)
+
+def test_supports_color_no_isatty(mocker):
+    class DummyStdout:
+        pass
+    mocker.patch("sys.stdout", DummyStdout())
+    assert _supports_color() is False
+
+def test_supports_color_isatty_false(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = False
+    mocker.patch("sys.stdout", mock_stdout)
+    assert _supports_color() is False
+
+def test_supports_color_term_dumb(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch.dict(os.environ, {"TERM": "dumb"})
+    assert _supports_color() is False
+
+def test_supports_color_no_color_env(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch.dict(os.environ, {"NO_COLOR": "1"})
+    assert _supports_color() is False
+
+def test_supports_color_non_windows_success(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "linux")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    assert _supports_color() is True
+
+def test_supports_color_win32_ctypes_exception(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "win32")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    mocker.patch.dict(sys.modules, {"ctypes": None})
+    assert _supports_color() is False
+
+def test_supports_color_win32_invalid_handle(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "win32")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    mock_ctypes = mocker.MagicMock()
+    mock_ctypes.windll.kernel32.GetStdHandle.return_value = -1
+    mocker.patch.dict(sys.modules, {"ctypes": mock_ctypes})
+    assert _supports_color() is False
+    
+    mock_ctypes.windll.kernel32.GetStdHandle.return_value = None
+    assert _supports_color() is False
+
+def test_supports_color_win32_get_console_mode_fail(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "win32")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    mock_ctypes = mocker.MagicMock()
+    mock_ctypes.windll.kernel32.GetStdHandle.return_value = 123
+    mock_ctypes.windll.kernel32.GetConsoleMode.return_value = False
+    mocker.patch.dict(sys.modules, {"ctypes": mock_ctypes})
+    assert _supports_color() is False
+
+def test_supports_color_win32_set_console_mode_fail(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "win32")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    mock_ctypes = mocker.MagicMock()
+    mock_ctypes.windll.kernel32.GetStdHandle.return_value = 123
+    mock_ctypes.windll.kernel32.GetConsoleMode.return_value = True
+    mock_ctypes.windll.kernel32.SetConsoleMode.return_value = False
+    mocker.patch.dict(sys.modules, {"ctypes": mock_ctypes})
+    assert _supports_color() is False
+
+def test_supports_color_win32_success(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "win32")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    mock_ctypes = mocker.MagicMock()
+    mock_ctypes.windll.kernel32.GetStdHandle.return_value = 123
+    mock_ctypes.windll.kernel32.GetConsoleMode.return_value = True
+    mock_ctypes.windll.kernel32.SetConsoleMode.return_value = True
+    mocker.patch.dict(sys.modules, {"ctypes": mock_ctypes})
+    assert _supports_color() is True
+
+def test_color_constants_when_color_enabled(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = True
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "linux")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    importlib.reload(pygitgo.utils.colors)
+    assert pygitgo.utils.colors.RED == "\033[31m"
+    assert pygitgo.utils.colors.GREEN == "\033[32m"
+    assert pygitgo.utils.colors.YELLOW == "\033[33m"
+    assert pygitgo.utils.colors.BLUE == "\033[34m"
+    assert pygitgo.utils.colors.CYAN == "\033[36m"
+    assert pygitgo.utils.colors.RESET == "\033[0m"
+
+def test_color_constants_when_color_disabled(mocker):
+    mock_stdout = mocker.MagicMock()
+    mock_stdout.isatty.return_value = False
+    mocker.patch("sys.stdout", mock_stdout)
+    mocker.patch("sys.platform", "linux")
+    mocker.patch.dict(os.environ, {}, clear=True)
+    
+    importlib.reload(pygitgo.utils.colors)
+    assert pygitgo.utils.colors.RED == ""
+    assert pygitgo.utils.colors.GREEN == ""
+    assert pygitgo.utils.colors.YELLOW == ""
+    assert pygitgo.utils.colors.BLUE == ""
+    assert pygitgo.utils.colors.CYAN == ""
+    assert pygitgo.utils.colors.RESET == ""
diff --git a/tests/test_git_branch.py b/tests/test_git_branch.py
index 6ec65d0..a33c7f9 100644
--- a/tests/test_git_branch.py
+++ b/tests/test_git_branch.py
@@ -1,16 +1,14 @@
 from pygitgo.commands.git_branch import (
-    git_new_branch, get_current_branch, is_branch_exist
+    git_new_branch, get_current_branch, is_branch_exist, get_main_branch, get_head_sha
 )
+from pygitgo.exceptions import GitCommandError, GitGoError
 import pytest
 
-
 def test_git_branch_logic(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_branch.run_command")
-
     branch_name = "hello-world"
     result = git_new_branch(branch_name)
     assert result == "hello-world"
-
     fake_run.assert_called_once_with(
         ["git", "checkout", "-b", "hello-world"], 
         loading_msg="Creating branch 'hello-world'...",
@@ -18,10 +16,9 @@ def test_git_branch_logic(mocker):
     )
 
 def test_git_branch_exists_jump_yes(mocker):
-    from pygitgo.exceptions import GitCommandError
     fake_run = mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=GitCommandError(["git", "checkout", "-b"]))
     mocker.patch("pygitgo.commands.git_branch.get_current_branch", return_value="main") 
-    mocker.patch("builtins.input", return_value="y")
+    mocker.patch("pygitgo.commands.git_branch.confirm", return_value=True)
     fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
     fake_error = mocker.patch("pygitgo.commands.git_branch.error")
 
@@ -30,29 +27,23 @@ def test_git_branch_exists_jump_yes(mocker):
 
     assert result == "existing-branch"
     fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'. It may already exist.")
-
     args = fake_jump.call_args[0][0]
     assert args.branch == branch_name
 
-
 def test_git_branch_exists_jump_no(mocker):
-    from pygitgo.exceptions import GitCommandError, GitGoError
     fake_run = mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=GitCommandError(["git", "checkout", "-b"]))
     mocker.patch("pygitgo.commands.git_branch.get_current_branch", return_value="main") 
-    mocker.patch("builtins.input", return_value="n")
+    mocker.patch("pygitgo.commands.git_branch.confirm", return_value=False)
     fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
     fake_error = mocker.patch("pygitgo.commands.git_branch.error")
 
     branch_name = "existing-branch"
-
     with pytest.raises(GitGoError):
         git_new_branch(branch_name)
     fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'. It may already exist.")
     fake_jump.assert_not_called()
 
-
 def test_git_branch_already_on_target_skips_prompt(mocker):
-    from pygitgo.exceptions import GitCommandError
     mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=GitCommandError(["git", "checkout", "-b"]))
     mocker.patch("pygitgo.commands.git_branch.get_current_branch", return_value="feat/safe-interruptions")
     fake_info = mocker.patch("pygitgo.commands.git_branch.info", create=True)
@@ -60,7 +51,6 @@ def test_git_branch_already_on_target_skips_prompt(mocker):
     fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
 
     result = git_new_branch("feat/safe-interruptions")
-
     assert result == "feat/safe-interruptions"
     fake_input.assert_not_called()
     fake_jump.assert_not_called() 
@@ -68,36 +58,59 @@ def test_git_branch_already_on_target_skips_prompt(mocker):
 
 def test_get_current_branch(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_branch.run_command", return_value='main')
-
     result = get_current_branch()
     assert result == 'main'
-
-    fake_run.assert_called_once_with(
-        ['git', 'branch', '--show-current']
-    )
+    fake_run.assert_called_once_with(['git', 'branch', '--show-current'])
 
 def test_is_branch_exist_true(mocker):
-    fake_run = mocker.patch(
-        'pygitgo.commands.git_branch.run_command',
-        return_value=True
-    )
-
+    fake_run = mocker.patch('pygitgo.commands.git_branch.run_command', return_value="origin/main")
     result = is_branch_exist('main')
-    assert result == True
-
-    fake_run.assert_called_once_with(
-        ["git", "branch", "-r", "--list", "*/main"]
-    )
+    assert result is True
 
 def test_is_branch_exist_false(mocker):
-    fake_run = mocker.patch(
-        'pygitgo.commands.git_branch.run_command',
-        return_value=False
-    )
-
+    fake_run = mocker.patch('pygitgo.commands.git_branch.run_command', return_value="")
     result = is_branch_exist('not-exist')
-    assert result == False
+    assert result is False
 
-    fake_run.assert_called_with(
-        ["git", "branch", "--list", 'not-exist']
-    )
+def test_get_current_branch_detached_head(mocker):
+    mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=["", "abcdef0"])
+    assert get_current_branch(safe=False) == "abcdef0"
+
+def test_get_current_branch_detached_head_safe_confirm_yes(mocker):
+    mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=["", "abcdef0", ""])
+    mocker.patch("pygitgo.commands.git_branch.confirm", return_value=True)
+    mocker.patch("builtins.input", return_value="save-branch")
+    assert get_current_branch(safe=True) == "save-branch"
+
+def test_get_current_branch_detached_head_safe_confirm_no(mocker):
+    mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=["", "abcdef0"])
+    mocker.patch("pygitgo.commands.git_branch.confirm", return_value=False)
+    with pytest.raises(GitGoError):
+        get_current_branch(safe=True)
+
+def test_get_main_branch_default(mocker):
+    mocker.patch("pygitgo.commands.git_branch.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=GitCommandError(["cmd"]))
+    assert get_main_branch() == "main"
+
+def test_get_main_branch_remote_invalid(mocker):
+    mocker.patch("pygitgo.commands.git_branch.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.git_branch.run_command", return_value="some other output")
+    assert get_main_branch() == "main"
+
+def test_get_main_branch_remote_valid(mocker):
+    mocker.patch("pygitgo.commands.git_branch.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.git_branch.run_command", return_value="* remote origin\n  HEAD branch: dev\n")
+    assert get_main_branch() == "dev"
+
+def test_get_head_sha(mocker):
+    mocker.patch("pygitgo.commands.git_branch.run_command", return_value="abcdef0123456789")
+    assert get_head_sha(short=False) == "abcdef0123456789"
+    assert get_head_sha(short=True) == "abcdef0123456789"
+
+def test_git_new_branch_current_branch_fails(mocker):
+    mocker.patch("pygitgo.commands.git_branch.run_command", side_effect=GitCommandError(["checkout"]))
+    mocker.patch("pygitgo.commands.git_branch.get_current_branch", side_effect=Exception("failed"))
+    mocker.patch("pygitgo.commands.git_branch.confirm", return_value=True)
+    mocker.patch("pygitgo.commands.jump.jump_operation")
+    assert git_new_branch("feat") == "feat"
diff --git a/tests/test_git_core.py b/tests/test_git_core.py
index 6393355..7c32f29 100644
--- a/tests/test_git_core.py
+++ b/tests/test_git_core.py
@@ -1,12 +1,25 @@
+from pygitgo.exceptions import GitGoError, GitCommandError
 from pygitgo.commands.git_core import (
-    git_commit, git_init, git_push
+    git_commit,
+    git_init,
+    git_push,
+    ensure_inside_git_repository,
+    is_git_repository,
+    has_local_changes,
+    is_rebase_in_progress,
+    has_any_commits,
+    get_recent_commits,
+    _get_signing_flags,
+    abort_pull_conflict
 )
-
+from pathlib import Path
+import pytest
 
 def test_git_commit(mocker):
     mocker.patch("pygitgo.commands.git_core._get_signing_flags", return_value=[])
     fake_sanitize = mocker.patch("pygitgo.commands.git_core.sanitize_signing_config")
     fake_run = mocker.patch("pygitgo.commands.git_core.run_command")
+    fake_run.side_effect = ["M file.py", None, None]
     
     result = git_commit("Testing the commit feature")
     assert result == True
@@ -44,7 +57,6 @@ def test_git_init_success(mocker):
     )
 
 def test_git_init_fallback(mocker):
-    from pygitgo.exceptions import GitCommandError
     mocker.patch('os.path.isdir', return_value=False)
     mocker.patch('pygitgo.commands.git_core.get_default_branch', return_value='main')
     
@@ -82,7 +94,6 @@ def test_git_push_already_ssh(mocker):
     )
 
 def test_git_push_no_remote(mocker):
-    from pygitgo.exceptions import GitCommandError
     fake_run = mocker.patch(
         'pygitgo.commands.git_core.run_command', 
         side_effect=[
@@ -163,7 +174,7 @@ def test_git_commit_skip_staging_does_not_run_git_add(mocker):
 
     for call in fake_run.call_args_list:
         args = call[0][0]
-        assert args[:2] != ["git", "add"], "git add should not run when skip_staging=True"
+        assert args[:2] != ["git", "add"]
 
 def test_git_commit_default_runs_git_add(mocker):
     mocker.patch("pygitgo.commands.git_core._get_signing_flags", return_value=[])
@@ -174,27 +185,177 @@ def test_git_commit_default_runs_git_add(mocker):
     add_call = fake_run.call_args_list[1][0][0]
     assert add_call == ["git", "add", "."]
 
-
 def test_abort_pull_conflict_active_rebase(mocker):
     mocker.patch("pathlib.Path.exists", return_value=True)
     mocker.patch("pygitgo.utils.cli_io.confirm", return_value=True)
     fake_run = mocker.patch("pygitgo.utils.executor.run_command")
     
-    from pygitgo.commands.git_core import abort_pull_conflict
     result = abort_pull_conflict()
     
     assert result is True
     fake_run.assert_called_once_with(["git", "rebase", "--abort"], loading_msg="Aborting sync...", ok_text="Sync aborted. Branch is back to how it was before the conflict.")
 
-
 def test_abort_pull_conflict_no_rebase(mocker):
     mocker.patch("pathlib.Path.exists", return_value=False)
     mocker.patch("pygitgo.utils.cli_io.confirm", return_value=True)
     mocker.patch("pygitgo.commands.git_branch.get_current_branch", return_value="main")
     fake_run = mocker.patch("pygitgo.utils.executor.run_command", side_effect=["", "", "0"])
     
-    from pygitgo.commands.git_core import abort_pull_conflict
     result = abort_pull_conflict()
     
     assert result is True
     fake_run.assert_any_call(["git", "reset", "--hard", "ORIG_HEAD"], loading_msg="Reverting to pre-pull state...", ok_text="Branch reset to its state before the last pull.")
+
+def test_ensure_inside_git_repository(mocker):
+    mocker.patch("pygitgo.commands.git_core.is_git_repository", return_value=True)
+    ensure_inside_git_repository()
+
+    mocker.patch("pygitgo.commands.git_core.is_git_repository", return_value=False)
+    with pytest.raises(GitGoError):
+        ensure_inside_git_repository()
+
+def test_is_git_repository(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="true")
+    assert is_git_repository() is True
+
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"]))
+    assert is_git_repository() is False
+
+def test_has_local_changes(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="M test.py")
+    assert has_local_changes() is True
+
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="")
+    assert has_local_changes() is False
+
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"]))
+    assert has_local_changes() is False
+
+def test_is_rebase_in_progress(mocker):
+    def mock_exists(self):
+        return "rebase-merge" in str(self)
+    mocker.patch.object(Path, "exists", mock_exists)
+    assert is_rebase_in_progress() is True
+
+def test_has_any_commits(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="abcdef")
+    assert has_any_commits() is True
+
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"]))
+    assert has_any_commits() is False
+
+def test_get_recent_commits(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="abc||author||date||msg\ninvalidline\ndef||author2||date2||msg2")
+    commits = get_recent_commits(number=2, branch="main")
+    assert len(commits) == 2
+    assert commits[0]["hash"] == "abc"
+    assert commits[1]["hash"] == "def"
+
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="")
+    assert get_recent_commits() == []
+
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"], stderr="err"))
+    with pytest.raises(GitGoError):
+        get_recent_commits()
+
+def test_get_signing_flags(mocker):
+    mock_path = mocker.MagicMock()
+    mock_path.exists.return_value = True
+    mocker.patch("pygitgo.commands.git_core.get_ssh_key_path", return_value=mock_path)
+    flags = _get_signing_flags()
+    assert len(flags) > 0
+
+    mock_path.exists.return_value = False
+    assert _get_signing_flags() == []
+
+def test_git_commit_no_changes(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", return_value="")
+    assert git_commit("msg") is False
+
+def test_git_commit_status_error(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"], stderr="not a git repository"))
+    with pytest.raises(GitGoError) as ex:
+        git_commit("msg")
+    assert "Not inside a git repository" in str(ex.value)
+
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=GitCommandError(["cmd"], stderr="other error"))
+    with pytest.raises(GitGoError) as ex:
+        git_commit("msg")
+    assert "Could not check repository status" in str(ex.value)
+
+def test_git_push_non_fast_forward(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=[
+        "git@github.com:user/repo.git",
+        GitCommandError(["push"], stderr="rejected (non-fast-forward)")
+    ])
+    mocker.patch("pygitgo.commands.git_core.is_ssh_url", return_value=True)
+    with pytest.raises(GitGoError) as ex:
+        git_push("main")
+    assert "Push rejected" in str(ex.value)
+
+def test_git_push_repository_not_found(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=[
+        "git@github.com:user/repo.git",
+        GitCommandError(["push"], stderr="repository not found")
+    ])
+    mocker.patch("pygitgo.commands.git_core.is_ssh_url", return_value=True)
+    with pytest.raises(GitGoError) as ex:
+        git_push("main")
+    assert "remote repository not found" in str(ex.value)
+
+def test_git_push_permission_denied(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=[
+        "git@github.com:user/repo.git",
+        GitCommandError(["push"], stderr="permission denied")
+    ])
+    mocker.patch("pygitgo.commands.git_core.is_ssh_url", return_value=True)
+    with pytest.raises(GitGoError) as ex:
+        git_push("main")
+    assert "permission denied" in str(ex.value)
+
+def test_git_push_other_error(mocker):
+    mocker.patch("pygitgo.commands.git_core.run_command", side_effect=[
+        "git@github.com:user/repo.git",
+        GitCommandError(["push"], stderr="unknown failure")
+    ])
+    mocker.patch("pygitgo.commands.git_core.is_ssh_url", return_value=True)
+    with pytest.raises(GitGoError) as ex:
+        git_push("main")
+    assert "Push failed: unknown failure" in str(ex.value)
+
+def test_abort_pull_conflict_active_rebase_decline(mocker):
+    mocker.patch("pathlib.Path.exists", return_value=True)
+    mocker.patch("pygitgo.utils.cli_io.confirm", return_value=False)
+    assert abort_pull_conflict() is False
+
+def test_abort_pull_conflict_active_rebase_error(mocker):
+    mocker.patch("pathlib.Path.exists", return_value=True)
+    mocker.patch("pygitgo.utils.cli_io.confirm", return_value=True)
+    mocker.patch("pygitgo.utils.executor.run_command", side_effect=GitCommandError(["cmd"], stderr="abort error"))
+    with pytest.raises(GitGoError):
+        abort_pull_conflict()
+
+def test_abort_pull_conflict_no_orig_head(mocker):
+    mocker.patch("pathlib.Path.exists", return_value=False)
+    mocker.patch("pygitgo.utils.executor.run_command", side_effect=GitCommandError(["cmd"]))
+    with pytest.raises(GitGoError) as ex:
+        abort_pull_conflict()
+    assert "No pull to undo" in str(ex.value)
+
+def test_abort_pull_conflict_branch_error(mocker):
+    mocker.patch("pathlib.Path.exists", return_value=False)
+    mocker.patch("pygitgo.utils.executor.run_command", return_value="")
+    mocker.patch("pygitgo.commands.git_branch.get_current_branch", side_effect=GitCommandError(["cmd"]))
+    with pytest.raises(GitGoError):
+        abort_pull_conflict()
+
+def test_abort_pull_conflict_reset_error(mocker):
+    mocker.patch("pathlib.Path.exists", return_value=False)
+    mocker.patch("pygitgo.commands.git_branch.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.utils.cli_io.confirm", return_value=True)
+    mocker.patch("pygitgo.utils.executor.run_command", side_effect=[
+        "",
+        GitCommandError(["cmd"], stderr="reset error")
+    ])
+    with pytest.raises(GitGoError):
+        abort_pull_conflict()
diff --git a/tests/test_init.py b/tests/test_init.py
index f0eeec0..4e425fd 100644
--- a/tests/test_init.py
+++ b/tests/test_init.py
@@ -1,12 +1,19 @@
-from unittest.mock import patch, MagicMock
+import pytest
+import urllib.error
+import zipfile
+import io
+import os
+from unittest.mock import patch, MagicMock, mock_open
 from pygitgo.exceptions import GitGoError
 from pygitgo.commands.init import (
     _resolve_lang,
     _scaffold_language,
     init_operation,
+    _fetch_available_templates,
+    _fetch_gitignore,
+    _download_and_extract_template,
+    _parse_template_slug
 )
-import pytest
-
 
 SAMPLE_AVAILABLE = {
     "python": "Python",
@@ -19,7 +26,6 @@
     "visualstudio": "VisualStudio",
 }
 
-
 def test_resolve_lang():
     assert _resolve_lang("py", SAMPLE_AVAILABLE) == "Python"
     assert _resolve_lang("python", SAMPLE_AVAILABLE) == "Python"
@@ -27,18 +33,22 @@ def test_resolve_lang():
     assert _resolve_lang("rust", SAMPLE_AVAILABLE) == "Rust"
     assert _resolve_lang("ruby", SAMPLE_AVAILABLE) == "Ruby"
 
-
 def test_resolve_lang_csharp_aliases():
     assert _resolve_lang("cs", SAMPLE_AVAILABLE) == "VisualStudio"
     assert _resolve_lang("csharp", SAMPLE_AVAILABLE) == "VisualStudio"
     assert _resolve_lang("dotnet", SAMPLE_AVAILABLE) == "Dotnet"
     assert _resolve_lang(".net", SAMPLE_AVAILABLE) == "Dotnet"
 
-
 def test_resolve_lang_unknown_raises():
-    with pytest.raises(GitGoError):
+    with pytest.raises(GitGoError) as ex:
         _resolve_lang("notalanguage", SAMPLE_AVAILABLE)
+    assert "No .gitignore template found" in str(ex.value)
 
+def test_resolve_lang_suggestions():
+    available = {"python": "Python", "pytorch": "PyTorch", "java": "Java"}
+    with pytest.raises(GitGoError) as ex:
+        _resolve_lang("pyt", available)
+    assert "pytorch" in str(ex.value)
 
 @patch("pygitgo.commands.init._fetch_gitignore")
 @patch("pygitgo.commands.init._fetch_available_templates")
@@ -54,7 +64,6 @@ def test_scaffold_language_python(mock_available, mock_gitignore, tmp_path):
     assert (tmp_path / ".python-version").exists()
     mock_gitignore.assert_called_once_with("Python")
 
-
 @patch("pygitgo.commands.init._fetch_gitignore")
 @patch("pygitgo.commands.init._fetch_available_templates")
 def test_scaffold_language_csharp(mock_available, mock_gitignore, tmp_path):
@@ -69,7 +78,6 @@ def test_scaffold_language_csharp(mock_available, mock_gitignore, tmp_path):
     assert (tmp_path / "Program.cs").exists()
     mock_gitignore.assert_called_once_with("VisualStudio")
 
-
 @patch("pygitgo.commands.init._download_and_extract_template")
 @patch("pygitgo.commands.init.git_init")
 def test_init_operation_template(mock_git_init, mock_download, tmp_path):
@@ -83,7 +91,6 @@ def test_init_operation_template(mock_git_init, mock_download, tmp_path):
     mock_download.assert_called_once_with("owner/repo", args.name)
     mock_git_init.assert_called_once()
 
-
 @patch("pygitgo.commands.init._scaffold_language")
 @patch("pygitgo.commands.init.git_init")
 def test_init_operation_lang(mock_git_init, mock_scaffold, tmp_path):
@@ -92,21 +99,193 @@ def test_init_operation_lang(mock_git_init, mock_scaffold, tmp_path):
     args.template = None
     args.lang = "python"
 
-    init_operation(args)
+    init_operation(args, standalone=True)
 
     mock_scaffold.assert_called_once_with("python", args.name, args.name)
     mock_git_init.assert_called_once()
 
-
 def test_parse_template_slug():
-    from pygitgo.commands.init import _parse_template_slug
-    
     assert _parse_template_slug("owner/repo") == "owner/repo"
     assert _parse_template_slug("https://github.com/owner/repo") == "owner/repo"
     assert _parse_template_slug("https://github.com/owner/repo.git") == "owner/repo"
     assert _parse_template_slug("git@github.com:owner/repo.git") == "owner/repo"
     
-    import pytest
-    from pygitgo.exceptions import GitGoError
     with pytest.raises(GitGoError):
-        _parse_template_slug("invalid_format")
\ No newline at end of file
+        _parse_template_slug("invalid_format")
+
+@patch("urllib.request.urlopen")
+def test_fetch_available_templates_success(mock_urlopen):
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = b'[{"name": "Python.gitignore", "type": "file"}, {"name": "Go.gitignore", "type": "file"}]'
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+
+    templates = _fetch_available_templates()
+    assert templates == {"python": "Python", "go": "Go"}
+
+@patch("urllib.request.urlopen")
+def test_fetch_available_templates_http_error(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Internal Server Error", {}, None)
+    with pytest.raises(GitGoError) as ex:
+        _fetch_available_templates()
+    assert "HTTP 500" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_fetch_available_templates_generic_error(mock_urlopen):
+    mock_urlopen.side_effect = Exception("network fail")
+    with pytest.raises(GitGoError) as ex:
+        _fetch_available_templates()
+    assert "network fail" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_fetch_gitignore_success(mock_urlopen):
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = b"gitignore data"
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+
+    content = _fetch_gitignore("Python")
+    assert content == "gitignore data"
+
+@patch("urllib.request.urlopen")
+def test_fetch_gitignore_not_found(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 404, "Not Found", {}, None)
+    with pytest.raises(GitGoError) as ex:
+        _fetch_gitignore("Python")
+    assert "not found in GitHub gitignore templates" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_fetch_gitignore_other_http_error(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Error", {}, None)
+    with pytest.raises(GitGoError) as ex:
+        _fetch_gitignore("Python")
+    assert "HTTP 500" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_fetch_gitignore_generic_error(mock_urlopen):
+    mock_urlopen.side_effect = Exception("network error")
+    with pytest.raises(GitGoError) as ex:
+        _fetch_gitignore("Python")
+    assert "Network error fetching gitignore" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_http_404(mock_urlopen, mocker):
+    mocker.patch("sys.stdout.isatty", return_value=True)
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 404, "Not Found", {}, None)
+    with pytest.raises(GitGoError) as ex:
+        _download_and_extract_template("owner/repo", "dir")
+    assert "not found on GitHub" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_http_other(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Error", {}, None)
+    with pytest.raises(GitGoError) as ex:
+        _download_and_extract_template("owner/repo", "dir")
+    assert "HTTP 500" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_generic_error(mock_urlopen):
+    mock_urlopen.side_effect = Exception("connection failed")
+    with pytest.raises(GitGoError) as ex:
+        _download_and_extract_template("owner/repo", "dir")
+    assert "connection failed" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_zip_error(mock_urlopen):
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = b"invalid zip data"
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+    with pytest.raises(GitGoError) as ex:
+        _download_and_extract_template("owner/repo", "dir")
+    assert "Failed to extract template" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_empty_zip(mock_urlopen):
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w") as zf:
+        pass
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = zip_buffer.getvalue()
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+    with pytest.raises(GitGoError) as ex:
+        _download_and_extract_template("owner/repo", "dir")
+    assert "Downloaded ZIP archive is empty" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_download_and_extract_template_success(mock_urlopen, tmp_path):
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w") as zf:
+        zf.writestr("root-dir/", "")
+        zf.writestr("root-dir/README.md", "hello template")
+        zf.writestr("root-dir/sub/", "")
+        zf.writestr("root-dir/sub/config.json", "{}")
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = zip_buffer.getvalue()
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+
+    target = tmp_path / "target"
+    _download_and_extract_template("owner/repo", str(target))
+    assert (target / "README.md").read_text() == "hello template"
+    assert (target / "sub" / "config.json").read_text() == "{}"
+
+@patch("pygitgo.commands.init._fetch_gitignore")
+@patch("pygitgo.commands.init._fetch_available_templates")
+def test_scaffold_language_all(mock_available, mock_gitignore, tmp_path):
+    mock_available.return_value = {
+        "node": "Node",
+        "rust": "Rust",
+        "dart": "Dart",
+        "flutter": "Flutter",
+        "go": "Go",
+        "dotnet": "Dotnet"
+    }
+    mock_gitignore.return_value = "gitignore"
+
+    os.makedirs(tmp_path / "node", exist_ok=True)
+    _scaffold_language("node", str(tmp_path / "node"), "node-app")
+    assert (tmp_path / "node" / "package.json").exists()
+
+    os.makedirs(tmp_path / "rust", exist_ok=True)
+    _scaffold_language("rust", str(tmp_path / "rust"), "rust-app")
+    assert (tmp_path / "rust" / "Cargo.toml").exists()
+    assert (tmp_path / "rust" / "src" / "main.rs").exists()
+
+    os.makedirs(tmp_path / "dart", exist_ok=True)
+    _scaffold_language("dart", str(tmp_path / "dart"), "dart-app")
+    assert (tmp_path / "dart" / "pubspec.yaml").exists()
+
+    os.makedirs(tmp_path / "flutter", exist_ok=True)
+    _scaffold_language("flutter", str(tmp_path / "flutter"), "flutter-app")
+    assert (tmp_path / "flutter" / "pubspec.yaml").exists()
+
+    os.makedirs(tmp_path / "go", exist_ok=True)
+    _scaffold_language("go", str(tmp_path / "go"), "go-app")
+    assert (tmp_path / "go" / "go.mod").exists()
+    assert (tmp_path / "go" / "main.go").exists()
+
+    os.makedirs(tmp_path / "dotnet", exist_ok=True)
+    _scaffold_language("dotnet", str(tmp_path / "dotnet"), "dotnet-app")
+    assert (tmp_path / "dotnet" / "dotnet-app.csproj").exists()
+    assert (tmp_path / "dotnet" / "Program.cs").exists()
+
+def test_init_operation_folder_not_empty(tmp_path):
+    args = MagicMock()
+    args.name = str(tmp_path / "non-empty")
+    os.makedirs(args.name)
+    with open(os.path.join(args.name, "file.txt"), "w") as f:
+        f.write("data")
+
+    with pytest.raises(GitGoError) as ex:
+        init_operation(args)
+    assert "already exists and is not empty" in str(ex.value)
+
+@patch("pygitgo.commands.init.git_init")
+@patch("pygitgo.commands.init._scaffold_language")
+def test_init_operation_error_cleanup(mock_scaffold, mock_git_init, tmp_path):
+    args = MagicMock()
+    args.name = str(tmp_path / "target-folder")
+    args.template = None
+    args.lang = "python"
+    mock_git_init.side_effect = Exception("init failed")
+
+    with pytest.raises(Exception):
+        init_operation(args)
+    assert not os.path.exists(args.name)
\ No newline at end of file
diff --git a/tests/test_jump.py b/tests/test_jump.py
index f3cbfa0..14feed5 100644
--- a/tests/test_jump.py
+++ b/tests/test_jump.py
@@ -1,12 +1,12 @@
-from pygitgo.commands.jump import undo_jump_operation, jump_operation
+from pygitgo.commands.jump import undo_jump_operation, jump_operation, _jump_interrupt_cleanup
 from pygitgo.exceptions import GitCommandError, GitGoError
 from conftest import capture_system_exit_code
 from argparse import Namespace
+from pathlib import Path
 import pytest
 
-
-def make_args(branch):
-    return Namespace(branch=branch)
+def make_args(branch, nested=False):
+    return Namespace(branch=branch, nested=nested)
 
 def test_undo_jump_operation_no_stash(mocker):
     fake_run = mocker.patch('pygitgo.commands.jump.run_command', return_value='')
@@ -26,7 +26,6 @@ def test_undo_jump_operation_no_stash(mocker):
     )
     fake_pop.assert_not_called()
 
-
 def test_undo_jump_operation_with_stash(mocker):
     fake_run = mocker.patch('pygitgo.commands.jump.run_command', return_value='')
     fake_pop = mocker.patch('pygitgo.commands.jump.git_stash_pop', return_value=True)
@@ -45,7 +44,6 @@ def test_undo_jump_operation_with_stash(mocker):
     )
     fake_pop.assert_called_once_with(ok_text="Canceled safely. Back on 'original_branch'. Your code is safe.")
 
-
 def test_undo_jump_operation_deletes_ghost_branch(mocker):
     fake_run = mocker.patch('pygitgo.commands.jump.run_command', return_value='')
     fake_pop = mocker.patch('pygitgo.commands.jump.git_stash_pop', return_value=True)
@@ -63,7 +61,6 @@ def test_undo_jump_operation_deletes_ghost_branch(mocker):
     )
     fake_pop.assert_called_once_with(ok_text="Canceled safely. Back on 'original_branch'. Your code is safe.")
 
-
 def test_jump_operation_same_branch(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='main')
     fake_warning = mocker.patch('pygitgo.commands.jump.warning')
@@ -71,7 +68,6 @@ def test_jump_operation_same_branch(mocker):
     assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 0
     fake_warning.assert_called_with("Already on branch 'main'.")
 
-
 def test_jump_operation_not_valid_repo(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.warning')
@@ -82,9 +78,7 @@ def test_jump_operation_not_valid_repo(mocker):
 
     assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 1
 
-
 def test_jump_operation_has_changes_exit(mocker):
-    # Tests when git_stash_push fails
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.run_command', return_value='M file.txt')
     mocker.patch('pygitgo.commands.jump.git_stash_push', return_value=False)
@@ -106,29 +100,25 @@ def test_jump_operation_has_changes_moves_to_branch(mocker):
     fake_stash.assert_called_once()
     fake_drop.assert_called_once()
 
-
 def test_jump_operation_no_changes(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
     mocker.patch('pygitgo.commands.jump.is_branch_exist', return_value=True)
-    fake_success = mocker.patch('pygitgo.commands.jump.success')
     mocker.patch('pygitgo.commands.jump.run_command', side_effect=['', 'ok', 'ok'])
 
     assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
-
 def test_jump_operation_save_changes_error(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.run_command', return_value='M file.txt')
     mocker.patch('pygitgo.commands.jump.git_stash_push', return_value=False)
-    mocker.patch('pathlib.Path.exists', return_value=True) # Mock index.lock exists
+    mocker.patch('pathlib.Path.exists', return_value=True) 
     fake_warning = mocker.patch('pygitgo.commands.jump.warning')
 
     with pytest.raises(GitGoError):
         jump_operation(make_args('main'))
     fake_warning.assert_any_call("A stale lock file is blocking git.")
 
-
 def test_jump_operation_branch_not_exist_cancel_operation(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
@@ -145,7 +135,6 @@ def test_jump_operation_branch_not_exist_cancel_operation(mocker):
     fake_info.assert_any_call("Jump canceled.")
     fake_pop.assert_called_once()
 
-
 def test_jump_operation_branch_not_exist_create_branch(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
@@ -166,7 +155,6 @@ def test_jump_operation_branch_not_exist_create_branch(mocker):
     fake_apply.assert_called_once()
     fake_drop.assert_called_once()
 
-
 def test_jump_operation_sync_fail_stay(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
@@ -187,7 +175,6 @@ def _run(*args, **kwargs):
     assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
     fake_info.assert_any_call("On 'feature', but not yet synced with 'main'.")
 
-
 def test_jump_operation_merge_conflict_cancel(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
@@ -207,7 +194,6 @@ def test_jump_operation_merge_conflict_cancel(mocker):
     assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
     fake_error.assert_any_call("CONFLICT: Your local changes clash with the target branch.")
 
-
 def test_jump_operation_merge_conflict_stay(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='master')
     mocker.patch('pygitgo.commands.jump.get_main_branch', return_value='main')
@@ -228,7 +214,6 @@ def test_jump_operation_merge_conflict_stay(mocker):
     fake_success.assert_any_call("On 'feature'. Fix the conflict markers in your files.")
     fake_warning.assert_any_call("Your stash backup is still saved. Run 'gitgo state list' to see it.")
 
-
 def test_jump_keyboard_interrupt_during_checkout(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='main')
     mocker.patch('pygitgo.commands.jump.is_branch_exist', return_value=True)
@@ -252,7 +237,6 @@ def side_effect(cmd, *args, **kwargs):
     mock_warning.assert_called_with("Jump interrupted (Ctrl+C).")
     mock_cleanup.assert_called_once_with('main', False, None)
 
-
 def test_jump_keyboard_interrupt_after_stash(mocker):
     mocker.patch('pygitgo.commands.jump.get_current_branch', return_value='main')
     mocker.patch('pygitgo.commands.jump.is_branch_exist', return_value=True)
@@ -275,3 +259,101 @@ def side_effect(cmd, *args, **kwargs):
 
     assert exc_info.value.code == 130
     mock_cleanup.assert_called_once_with('main', True, None)
+
+def test_undo_jump_operation_delete_branch_fails(mocker):
+    fake_run = mocker.patch('pygitgo.commands.jump.run_command')
+    fake_run.side_effect = [
+        "",
+        GitCommandError(["branch", "-D", "feat"])
+    ]
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    undo_jump_operation("main", False, created_branch="feat")
+    fake_warning.assert_any_call("Could not delete branch 'feat'. Remove it manually with: git branch -D feat")
+
+def test_undo_jump_operation_pop_fails(mocker):
+    mocker.patch('pygitgo.commands.jump.run_command', return_value="")
+    mocker.patch("pygitgo.commands.jump.git_stash_pop", return_value=False)
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    undo_jump_operation("main", True)
+    fake_warning.assert_any_call("Could not restore your unsaved changes automatically. Run 'gitgo state list' to recover them.")
+
+def test_jump_interrupt_cleanup_exceptions(mocker):
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=GitCommandError(["rebase", "--abort"]))
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="feat")
+    mocker.patch("pygitgo.commands.jump.undo_jump_operation", side_effect=GitCommandError(["undo"]))
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    _jump_interrupt_cleanup("main", True, "feat")
+    fake_warning.assert_any_call("Could not auto-revert. You are on 'feat'.")
+
+def test_jump_interrupt_cleanup_pop_fails(mocker):
+    mocker.patch("pygitgo.commands.jump.run_command", return_value="")
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.git_stash_pop", return_value=False)
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    _jump_interrupt_cleanup("main", True, None)
+    fake_warning.assert_any_call("Could not restore stash automatically. Run 'gitgo state list' to find it.")
+
+def test_jump_operation_status_error(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=GitCommandError(["status"], stderr="some other error"))
+    with pytest.raises(GitGoError) as ex:
+        jump_operation(make_args("feat"))
+    assert "Could not check repository status" in str(ex.value)
+
+def test_jump_operation_stash_fails_rebase_in_progress(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=["M file.py", ""])
+    mocker.patch("pygitgo.commands.jump.git_stash_push", return_value=False)
+    def mock_exists(self):
+        return "rebase-merge" in str(self)
+    mocker.patch.object(Path, "exists", mock_exists)
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    with pytest.raises(GitGoError):
+        jump_operation(make_args("feat"))
+    fake_warning.assert_any_call("A rebase is in progress. Finish or abort it first.")
+
+def test_jump_operation_stash_fails_generic(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=["M file.py", ""])
+    mocker.patch("pygitgo.commands.jump.git_stash_push", return_value=False)
+    mocker.patch("pathlib.Path.exists", return_value=False)
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    with pytest.raises(GitGoError):
+        jump_operation(make_args("feat"))
+    fake_warning.assert_any_call("Could not auto-save changes before switching.")
+
+def test_jump_operation_new_branch_not_exist_cancel_pop_fails(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.is_branch_exist", return_value=False)
+    mocker.patch("pygitgo.commands.jump.confirm", return_value=False)
+    mocker.patch("pygitgo.commands.jump.run_command", return_value="M file.py")
+    mocker.patch("pygitgo.commands.jump.git_stash_push", return_value=True)
+    mocker.patch("pygitgo.commands.jump.git_stash_pop", return_value=False)
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    assert capture_system_exit_code(lambda: jump_operation(make_args("feat"))) == 0
+    fake_warning.assert_any_call("Could not restore changes automatically. Run 'gitgo state list' to recover them.")
+
+def test_jump_operation_sync_fails_generic(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.is_branch_exist", return_value=True)
+    mocker.patch("pygitgo.commands.jump.get_main_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=[
+        "",
+        "",
+        GitCommandError(["pull"], stderr="network error")
+    ])
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    assert capture_system_exit_code(lambda: jump_operation(make_args("feat"))) == 0
+    fake_warning.assert_any_call("Could not sync from 'main': no remote or no internet.")
+
+def test_jump_operation_stash_apply_fails_drop_fails(mocker):
+    mocker.patch("pygitgo.commands.jump.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.is_branch_exist", return_value=True)
+    mocker.patch("pygitgo.commands.jump.get_main_branch", return_value="main")
+    mocker.patch("pygitgo.commands.jump.git_stash_push", return_value=True)
+    mocker.patch("pygitgo.commands.jump.git_stash_apply", return_value=True)
+    mocker.patch("pygitgo.commands.jump.git_stash_drop", return_value=False)
+    mocker.patch("pygitgo.commands.jump.run_command", side_effect=lambda *a, **kw: "M file.py" if a[0] == ["git", "status", "--porcelain"] else "ok")
+    fake_warning = mocker.patch("pygitgo.commands.jump.warning")
+    assert capture_system_exit_code(lambda: jump_operation(make_args("feat"))) == 0
+    fake_warning.assert_any_call("Could not clean up the temporary stash. Run 'gitgo state list' to remove it manually.")
diff --git a/tests/test_link.py b/tests/test_link.py
index 238fae4..e7a12ba 100644
--- a/tests/test_link.py
+++ b/tests/test_link.py
@@ -1,8 +1,8 @@
 from pygitgo.exceptions import GitCommandError, GitGoError
-from pygitgo.commands.link import link_operation
+from pygitgo.commands.link import link_operation, _link_interrupt_cleanup, link_core
 from argparse import Namespace
 import pytest
-
+import sys
 
 def test_link_invalid_url():
     args = Namespace(url="invalid-url", message="Initial commit")
@@ -10,7 +10,6 @@ def test_link_invalid_url():
         link_operation(args)
     assert "Invalid remote repository URL:" in str(exc_info.value)
 
-
 def test_link_existing_repo(mocker):
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
     mocker.patch("pygitgo.commands.link.git_init", return_value=False)
@@ -27,7 +26,6 @@ def test_link_existing_repo(mocker):
     fake_success.assert_not_called()
     fake_commit.assert_not_called()
 
-
 def test_link_new_repo_no_remote_refs(mocker):
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
     mocker.patch("pygitgo.commands.link.git_init", return_value=True)
@@ -41,9 +39,9 @@ def test_link_new_repo_no_remote_refs(mocker):
     fake_run = mocker.patch(
         "pygitgo.commands.link.run_command",
         side_effect=[
-            "",       # git branch -m main (branch rename)
-            "",       # git ls-remote (no remote refs)
-            "abc123", # git rev-parse HEAD (has local commits)
+            "",       
+            "",       
+            "abc123", 
         ]
     )
 
@@ -56,7 +54,6 @@ def test_link_new_repo_no_remote_refs(mocker):
     fake_run.assert_any_call(["git", "ls-remote", "--heads", "origin", "main"], loading_msg="Checking remote branches...", ok_text="Remote branches checked.")
     fake_push.assert_called_once_with("main")
 
-
 def test_link_new_repo_with_remote_refs_pull_success(mocker):
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
     mocker.patch("pygitgo.commands.link.git_init", return_value=True)
@@ -71,9 +68,9 @@ def test_link_new_repo_with_remote_refs_pull_success(mocker):
     fake_run = mocker.patch(
         "pygitgo.commands.link.run_command",
         side_effect=[
-            "1234567890abcdef refs/heads/main",  # remote_refs check
-            "Successfully pulled",                # git pull
-            "123456"                              # git rev-parse HEAD
+            "1234567890abcdef refs/heads/main",  
+            "Successfully pulled",                
+            "123456"                              
         ]
     )
 
@@ -88,7 +85,6 @@ def test_link_new_repo_with_remote_refs_pull_success(mocker):
     fake_success.assert_not_called()
     fake_push.assert_called_once_with("main")
 
-
 def test_link_new_repo_with_remote_refs_pull_failure(mocker):
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
     mocker.patch("pygitgo.commands.link.git_init", return_value=True)
@@ -103,9 +99,9 @@ def test_link_new_repo_with_remote_refs_pull_failure(mocker):
     fake_run = mocker.patch(
         "pygitgo.commands.link.run_command",
         side_effect=[
-            "1234567890abcdef refs/heads/main",  # remote_refs check
-            GitCommandError(["git", "pull"]),    # git pull fails
-            "123456"                             # git rev-parse HEAD (if reached)
+            "1234567890abcdef refs/heads/main",  
+            GitCommandError(["git", "pull"]),    
+            "123456"                             
         ]
     )
 
@@ -116,7 +112,6 @@ def test_link_new_repo_with_remote_refs_pull_failure(mocker):
     fake_error.assert_called_once_with("Failed to merge remote content. You may need to resolve conflicts manually.")
     fake_warning.assert_any_call("Run: git pull origin main --allow-unrelated-histories")
 
-
 def test_link_core_already_initialized_commits_and_pushes(mocker):
     from pygitgo.commands.link import link_core
 
@@ -147,12 +142,10 @@ def test_link_core_already_initialized_commits_and_pushes(mocker):
     fake_add_remote.assert_called_once_with("git@github.com:user/repo.git")
     fake_push.assert_called_once_with("main")
 
-
 def test_link_keyboard_interrupt_during_commit(mocker):
     from pygitgo.commands.link import link_core
 
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
-    # Return False so no URL conversion happens; the cleanup URL stays as HTTPS.
     mocker.patch("pygitgo.commands.link.check_connection", return_value=False)
     mocker.patch("pygitgo.commands.link.git_init", return_value=True)
     mocker.patch("pygitgo.commands.link.git_commit", side_effect=KeyboardInterrupt())
@@ -171,12 +164,10 @@ def test_link_keyboard_interrupt_during_commit(mocker):
         False,
     )
 
-
 def test_link_keyboard_interrupt_after_remote_added(mocker):
     from pygitgo.commands.link import link_core
 
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
-    # Return False so no URL conversion happens; the cleanup URL stays as HTTPS.
     mocker.patch("pygitgo.commands.link.check_connection", return_value=False)
     mocker.patch("pygitgo.commands.link.git_init", return_value=True)
     mocker.patch("pygitgo.commands.link.git_commit", return_value=True)
@@ -195,7 +186,6 @@ def test_link_keyboard_interrupt_after_remote_added(mocker):
         True,
     )
 
-
 def test_link_existing_repo_failure(mocker):
     mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
     mocker.patch("pygitgo.commands.link.git_init", return_value=False)
@@ -208,4 +198,74 @@ def test_link_existing_repo_failure(mocker):
     
     assert "Connection failed" in str(exc_info.value)
     fake_add_remote.assert_called_once_with("git@github.com:user/repo.git")
-    fake_confirm.assert_called_once_with(ok_text="Remote linked to existing repository.")
\ No newline at end of file
+    fake_confirm.assert_called_once_with(ok_text="Remote linked to existing repository.")
+
+def test_link_interrupt_cleanup_exceptions(mocker):
+    mocker.patch("pygitgo.commands.link.run_command", side_effect=GitCommandError(["merge", "--abort"]))
+    mocker.patch("shutil.rmtree", side_effect=Exception("rmtree failed"))
+    fake_warning = mocker.patch("pygitgo.commands.link.warning")
+    _link_interrupt_cleanup("https://url.git", True, False, True)
+    fake_warning.assert_any_call("Could not auto-remove '.git' folder.")
+
+def test_link_interrupt_cleanup_not_initialized(mocker):
+    mocker.patch("pygitgo.commands.link.run_command", return_value="")
+    fake_success = mocker.patch("pygitgo.commands.link.success")
+    _link_interrupt_cleanup("https://url.git", False, False, False)
+    fake_success.assert_called_once_with("No Git state was changed. Your files are safe.")
+
+def test_link_core_ssh_check_fails(mocker):
+    mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
+    mocker.patch("pygitgo.commands.link.check_connection", return_value=False)
+    mocker.patch("pygitgo.commands.link.git_init", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_commit", return_value=True)
+    mocker.patch("pygitgo.commands.link.add_remote_origin")
+    mocker.patch("pygitgo.commands.link.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
+    fake_warning = mocker.patch("pygitgo.commands.link.warning")
+    mocker.patch("pygitgo.commands.link.run_command", return_value="")
+    mocker.patch("pygitgo.commands.link.git_push")
+    mocker.patch("pygitgo.commands.link.banner")
+
+    link_core("https://github.com/user/repo.git", "message", silent=True)
+    fake_warning.assert_called_once_with("SSH check failed. Using HTTPS — you may be prompted for credentials on push.")
+
+def test_link_core_branch_fails(mocker):
+    mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_init", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_commit", return_value=True)
+    mocker.patch("pygitgo.commands.link.add_remote_origin")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_current_branch", side_effect=GitCommandError(["branch"]))
+
+    with pytest.raises(GitGoError) as ex:
+        link_core("git@github.com:user/repo.git", "message", silent=True)
+    assert "Could not determine the current branch" in str(ex.value)
+
+def test_link_core_ls_remote_fails(mocker):
+    mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_init", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_commit", return_value=True)
+    mocker.patch("pygitgo.commands.link.add_remote_origin")
+    mocker.patch("pygitgo.commands.link.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.git_push")
+    mocker.patch("pygitgo.commands.link.run_command", side_effect=[
+        GitCommandError(["ls-remote"]),
+        GitCommandError(["rev-parse"])
+    ])
+    link_core("git@github.com:user/repo.git", "message", silent=True)
+
+def test_link_core_no_commits(mocker):
+    mocker.patch("pygitgo.commands.link.validate_repo_url", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_init", return_value=True)
+    mocker.patch("pygitgo.commands.link.git_commit", return_value=True)
+    mocker.patch("pygitgo.commands.link.add_remote_origin")
+    mocker.patch("pygitgo.commands.link.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
+    mocker.patch("pygitgo.commands.link.run_command", side_effect=[
+        "",
+        GitCommandError(["rev-parse"])
+    ])
+    fake_info = mocker.patch("pygitgo.commands.link.info")
+    link_core("git@github.com:user/repo.git", "message", silent=True)
+    fake_info.assert_called_once_with("Repository is currently empty. Add files and run 'gitgo push' to upload.")
\ No newline at end of file
diff --git a/tests/test_push.py b/tests/test_push.py
index cfa85c6..860b5e9 100644
--- a/tests/test_push.py
+++ b/tests/test_push.py
@@ -1,18 +1,16 @@
-from pygitgo.commands.push import push_operation
-from pygitgo.exceptions import GitGoError
+from pygitgo.commands.push import push_operation, _push_interrupt_cleanup
+from pygitgo.exceptions import GitCommandError, GitGoError
 from argparse import Namespace
 import pytest
-
+import sys
 
 def test_push_new_branch_flag_no_name(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
-
     args = Namespace(branch=None, message="Init commit", new=True, select=False)
     with pytest.raises(GitGoError) as exc_info:
         push_operation(args)
     assert "Branch name required when using --new flag!" in str(exc_info.value)
 
-
 def test_push_new_branch_success(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     fake_new_branch = mocker.patch("pygitgo.commands.push.git_new_branch")
@@ -27,7 +25,6 @@ def test_push_new_branch_success(mocker):
     fake_commit.assert_called_once_with("Init commit")
     fake_push.assert_called_once_with("feature-branch")
 
-
 def test_push_wrong_branch_auto_switch(mocker):
     mocker.patch("pygitgo.commands.push.is_branch_exist", return_value=True)
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
@@ -49,7 +46,6 @@ def test_push_wrong_branch_auto_switch(mocker):
     fake_commit.assert_called_once_with("Init commit")
     fake_push.assert_called_once_with("feature-branch")
 
-
 def test_push_wrong_branch_auto_switch_refused(mocker):
     mocker.patch("pygitgo.commands.push.is_branch_exist", return_value=True)
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
@@ -62,7 +58,6 @@ def test_push_wrong_branch_auto_switch_refused(mocker):
 
     fake_jump.assert_not_called()
 
-
 def test_push_default_branch_and_msg(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.get_config", return_value="Default Msg")
@@ -77,7 +72,6 @@ def test_push_default_branch_and_msg(mocker):
     fake_commit.assert_called_once_with("Default Msg")
     fake_push.assert_called_once_with("main")
 
-
 def test_push_select_clean(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.get_changed_files", return_value=[])
@@ -90,7 +84,6 @@ def test_push_select_clean(mocker):
     fake_info.assert_called_once_with("\nWorking tree is clean. Nothing to select.")
     fake_warning.assert_called_once_with("Make some changes first before using GitGo to commit and push.")
 
-
 def test_push_select_no_files_chosen(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.get_changed_files", return_value=["file1.txt", "file2.txt"])
@@ -102,7 +95,6 @@ def test_push_select_no_files_chosen(mocker):
 
     fake_info.assert_called_once_with("\nNo files selected. Push aborted.\n")
 
-
 def test_push_select_success(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.get_changed_files", return_value=["file1.txt", "file2.txt"])
@@ -119,7 +111,6 @@ def test_push_select_success(mocker):
     fake_commit.assert_called_once_with("Selective push", loading_msg="Committing selected files...", skip_staging=True)
     fake_push.assert_called_once_with("main")
 
-
 def test_push_clean_but_unpushed_commits(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.git_commit", return_value=False) 
@@ -135,7 +126,6 @@ def test_push_clean_but_unpushed_commits(mocker):
     fake_warning.assert_called_once_with("\nNo changes to commit, but found unpushed commits. Pushing to remote...")
     fake_push.assert_called_once_with("main")
 
-
 def test_push_clean_and_up_to_date(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.git_commit", return_value=False) 
@@ -152,14 +142,13 @@ def test_push_clean_and_up_to_date(mocker):
     fake_warning.assert_called_once_with("Make some changes first before using GitGo to commit and push.")
     fake_push.assert_not_called()
 
-
 def test_push_keyboard_interrupt_no_changes_made(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.git_commit", side_effect=KeyboardInterrupt)
     fake_run = mocker.patch("pygitgo.commands.push.run_command")
     fake_run.return_value = "initial_hash" 
     fake_warning = mocker.patch("pygitgo.commands.push.warning")
-    fake_info = mocker.patch("pygitgo.commands.push.info")
+    mocker.patch("pygitgo.commands.push.info")
 
     fake_run.side_effect = lambda cmd, *a, **kw: "" if cmd == ["git", "status", "--porcelain"] else "initial_hash"
 
@@ -170,7 +159,6 @@ def test_push_keyboard_interrupt_no_changes_made(mocker):
     assert sys_exit.value.code == 130
     fake_warning.assert_any_call("Push interrupted (Ctrl+C).")
 
-
 def test_push_keyboard_interrupt_commit_made(mocker):
     mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
     mocker.patch("pygitgo.commands.push.git_commit", return_value=True)
@@ -188,4 +176,38 @@ def test_push_keyboard_interrupt_commit_made(mocker):
     fake_warning.assert_any_call("Push interrupted (Ctrl+C).")
     fake_info.assert_any_call("Commit was saved locally on 'main' but was not pushed.")
 
+def test_push_interrupt_cleanup_exceptions(mocker):
+    mocker.patch("pygitgo.commands.push.get_current_branch", side_effect=Exception("error"))
+    mocker.patch("pygitgo.commands.push.get_head_sha", side_effect=GitCommandError(["cmd"]))
+    fake_run = mocker.patch("pygitgo.commands.push.run_command", side_effect=GitCommandError(["cmd"]))
+    fake_warning = mocker.patch("pygitgo.commands.push.warning")
+
+    _push_interrupt_cleanup("main", "head", "new-branch")
+    fake_warning.assert_any_call("Could not auto-remove 'new-branch'.")
+
+def test_push_operation_no_msg_branch_does_not_exist(mocker):
+    mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.push.is_branch_exist", return_value=False)
+    mocker.patch("pygitgo.commands.push.git_commit", return_value=True)
+    mocker.patch("pygitgo.commands.push.git_push")
+    mocker.patch("pygitgo.commands.push.banner")
+    args = Namespace(branch="new-feature", message=None, new=False, select=False)
+    push_operation(args)
 
+def test_push_unpushed_check_unknown_revision_error(mocker):
+    mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.push.git_commit", return_value=False)
+    mocker.patch("pygitgo.commands.push.run_command", side_effect=GitCommandError(["log"], stderr="fatal: unknown revision or path not in the working tree"))
+    fake_warning = mocker.patch("pygitgo.commands.push.warning")
+    args = Namespace(branch=None, message="message", new=False, select=False)
+    push_operation(args)
+    fake_warning.assert_any_call("\nBranch has no upstream yet. Push first to set it: 'gitgo push'.")
+
+def test_push_unpushed_check_other_error(mocker):
+    mocker.patch("pygitgo.commands.push.get_current_branch", return_value="main")
+    mocker.patch("pygitgo.commands.push.git_commit", return_value=False)
+    mocker.patch("pygitgo.commands.push.run_command", side_effect=GitCommandError(["log"], stderr="some other error"))
+    fake_warning = mocker.patch("pygitgo.commands.push.warning")
+    args = Namespace(branch=None, message="message", new=False, select=False)
+    push_operation(args)
+    fake_warning.assert_any_call("\nCould not verify remote status: some other error")
diff --git a/tests/test_repo.py b/tests/test_repo.py
index 9010d06..9a97118 100644
--- a/tests/test_repo.py
+++ b/tests/test_repo.py
@@ -4,23 +4,25 @@
     _get_github_token,
     create_github_repo,
     repo_operation,
+    _clear_saved_token,
+    parse_repo_fullname,
+    delete_github_repo
 )
 import urllib.error
+import subprocess
 import pytest
-
+import sys
 
 @patch.dict("os.environ", {"GITHUB_TOKEN": "test-token"})
 def test_get_github_token_env():
     assert _get_github_token() == "test-token"
 
-
 @patch.dict("os.environ", {}, clear=True)
 @patch("subprocess.run")
 def test_get_github_token_gh_cli(mock_run):
     mock_run.return_value = MagicMock(returncode=0, stdout=" cli-token ")
     assert _get_github_token() == "cli-token"
 
-
 @patch.dict("os.environ", {}, clear=True)
 @patch("subprocess.run")
 @patch("pygitgo.commands.repo.get_config", return_value="cached-token")
@@ -29,7 +31,6 @@ def test_get_github_token_cached(mock_get_config, mock_run):
     assert _get_github_token() == "cached-token"
     mock_get_config.assert_called_once_with("github-token", "")
 
-
 @patch.dict("os.environ", {}, clear=True)
 @patch("subprocess.run")
 @patch("pygitgo.commands.repo.get_config", return_value="")
@@ -42,7 +43,6 @@ def test_get_github_token_prompt(mock_input, mock_set_config, mock_open_url, moc
     mock_open_url.assert_called_once()
     mock_set_config.assert_called_once_with("github-token", "user-pasted-token", silent=True)
 
-
 @patch.dict("os.environ", {}, clear=True)
 @patch("subprocess.run")
 @patch("pygitgo.commands.repo.get_config", return_value="")
@@ -53,7 +53,6 @@ def test_get_github_token_cancelled(mock_input, mock_open_url, mock_get_config,
     with pytest.raises(GitGoError, match="Cancelled"):
         _get_github_token()
 
-
 @patch("urllib.request.urlopen")
 def test_create_github_repo_success(mock_urlopen):
     mock_response = MagicMock()
@@ -63,7 +62,6 @@ def test_create_github_repo_success(mock_urlopen):
     res = create_github_repo("repo", token="token")
     assert res["clone_url"] == "https://github.com/user/repo.git"
 
-
 @patch("urllib.request.urlopen")
 @patch("pygitgo.commands.repo._get_github_token", return_value="old-token")
 @patch("pygitgo.commands.repo._prompt_for_token", return_value="new-token")
@@ -87,7 +85,6 @@ def test_create_github_repo_401_retry(mock_clear, mock_prompt, mock_token, mock_
     mock_clear.assert_called_once()
     mock_prompt.assert_called_once()
 
-
 @patch("pygitgo.commands.repo._get_github_token", return_value="token")
 @patch("pygitgo.commands.repo.create_github_repo")
 def test_repo_operation_verbose(mock_create, mock_token, capsys):
@@ -104,7 +101,6 @@ def test_repo_operation_verbose(mock_create, mock_token, capsys):
     assert "Successfully created remote repository" in captured.out
     assert "gitgo link" in captured.out
 
-
 @patch("pygitgo.commands.repo._get_github_token", return_value="token")
 @patch("pygitgo.commands.repo.create_github_repo")
 def test_repo_operation_silent(mock_create, mock_token, capsys):
@@ -120,3 +116,144 @@ def test_repo_operation_silent(mock_create, mock_token, capsys):
     captured = capsys.readouterr()
     assert "Successfully created remote repository" in captured.out
     assert "gitgo link" not in captured.out
+
+def test_clear_saved_token(mocker):
+    mock_run = mocker.patch("subprocess.run")
+    _clear_saved_token()
+    mock_run.assert_called_once_with(
+        ["git", "config", "--global", "--unset", "gitgo.github-token"],
+        capture_output=True
+    )
+
+    mock_run.side_effect = Exception("failed")
+    _clear_saved_token()
+
+@patch.dict("os.environ", {}, clear=True)
+def test_get_github_token_gh_cli_timeout(mocker):
+    mocker.patch("subprocess.run", side_effect=subprocess.TimeoutExpired(["gh"], 5))
+    mocker.patch("pygitgo.commands.repo.get_config", return_value="cached-token")
+    assert _get_github_token() == "cached-token"
+
+@patch("urllib.request.urlopen")
+def test_create_github_repo_already_exists(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 422
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 422, "Unprocessable Entity", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        create_github_repo("repo", token="token")
+    assert "already exists on GitHub" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_create_github_repo_401_max_retries(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 401
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 401, "Unauthorized", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        create_github_repo("repo", token="token", retry_count=3)
+    assert "GitHub authentication failed" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_create_github_repo_other_http_errors(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 500
+    mock_err.read.return_value = b'{"message": "internal error"}'
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Internal Error", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        create_github_repo("repo", token="token")
+    assert "GitHub API error 500: internal error" in str(ex.value)
+
+    mock_err.read.return_value = b"plain text error"
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Internal Error", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        create_github_repo("repo", token="token")
+    assert "GitHub API error 500: plain text error" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_create_github_repo_url_error(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.URLError("reason failure")
+    with pytest.raises(GitGoError) as ex:
+        create_github_repo("repo", token="token")
+    assert "Network error creating repo: reason failure" in str(ex.value)
+
+@patch("pygitgo.commands.repo._get_github_token", return_value="token")
+@patch("pygitgo.commands.repo.create_github_repo")
+def test_repo_operation_no_name(mock_create, mock_token, mocker):
+    mock_create.return_value = {"clone_url": "https://github.com/user/current-dir.git"}
+    mocker.patch("os.path.abspath", return_value="/path/current-dir")
+    mocker.patch("os.path.basename", return_value="current-dir")
+    args = MagicMock()
+    args.name = None
+    args.private = False
+    args.description = None
+    url = repo_operation(args, silent=True)
+    assert url == "https://github.com/user/current-dir.git"
+
+@patch("pygitgo.commands.repo._get_github_token", return_value="token")
+@patch("pygitgo.commands.repo.create_github_repo")
+def test_repo_operation_failure(mock_create, mock_token, mocker):
+    mock_create.side_effect = Exception("failed creation")
+    args = MagicMock()
+    args.name = "repo"
+    args.private = False
+    args.description = None
+    with pytest.raises(Exception):
+         repo_operation(args, silent=True)
+
+def test_parse_repo_fullname():
+    assert parse_repo_fullname("https://github.com/owner/repo.git") == "owner/repo"
+    assert parse_repo_fullname("git@github.com:owner/repo.git") == "owner/repo"
+    assert parse_repo_fullname("invalid-url") is None
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_success(mock_urlopen):
+    mock_resp = MagicMock()
+    mock_urlopen.return_value.__enter__.return_value = mock_resp
+    assert delete_github_repo("owner/repo", token="token") is True
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_403(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 403
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 403, "Forbidden", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        delete_github_repo("owner/repo", token="token")
+    assert "does not have 'delete_repo' scope" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_404(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 404
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 404, "Not Found", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        delete_github_repo("owner/repo", token="token")
+    assert "not found on GitHub" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_other_errors(mock_urlopen):
+    mock_err = MagicMock()
+    mock_err.code = 500
+    mock_err.read.return_value = b'{"message": "delete error"}'
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Error", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        delete_github_repo("owner/repo", token="token")
+    assert "GitHub API error 500 while deleting repo: delete error" in str(ex.value)
+
+    mock_err.read.return_value = b"plain text error"
+    mock_urlopen.side_effect = urllib.error.HTTPError("url", 500, "Error", {}, mock_err)
+    with pytest.raises(GitGoError) as ex:
+        delete_github_repo("owner/repo", token="token")
+    assert "GitHub API error 500 while deleting repo: plain text error" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_url_error(mock_urlopen):
+    mock_urlopen.side_effect = urllib.error.URLError("reason")
+    with pytest.raises(GitGoError) as ex:
+         delete_github_repo("owner/repo", token="token")
+    assert "Network error deleting repo" in str(ex.value)
+
+@patch("urllib.request.urlopen")
+def test_delete_github_repo_generic_exception(mock_urlopen):
+    mock_urlopen.side_effect = Exception("error")
+    with pytest.raises(GitGoError) as ex:
+         delete_github_repo("owner/repo", token="token")
+    assert "Unexpected error" in str(ex.value)
diff --git a/tests/test_state.py b/tests/test_state.py
index ee2a972..9ca06e3 100644
--- a/tests/test_state.py
+++ b/tests/test_state.py
@@ -1,10 +1,10 @@
 from pygitgo.commands.state import (
     delete_state, save_state, load_state, validate_state_id,
-    all_save_state
+    all_save_state, state_operation
 )
+from pygitgo.exceptions import GitCommandError, GitGoError
 import pytest
 
-
 @pytest.mark.parametrize('state_id', ['1', '3', '11', '00002'])
 def test_validate_state_id(state_id, mocker):
     fake_error = mocker.patch('pygitgo.commands.state.error')
@@ -12,7 +12,6 @@ def test_validate_state_id(state_id, mocker):
     assert result is True
     fake_error.assert_not_called()
 
-
 @pytest.mark.parametrize('state_id', ['-1', '-3', '-11', '-00002'])
 def test_validate_state_id_negative(state_id, mocker):
     fake_error = mocker.patch('pygitgo.commands.state.error')
@@ -20,7 +19,6 @@ def test_validate_state_id_negative(state_id, mocker):
     assert result is False
     fake_error.assert_called_with("Invalid ID. Range is 1 to 12.")
 
-
 @pytest.mark.parametrize('state_id', ['4', '10', '15', '0000020'])
 def test_validate_state_id_out_scope(state_id, mocker):
     fake_error = mocker.patch('pygitgo.commands.state.error')
@@ -28,16 +26,12 @@ def test_validate_state_id_out_scope(state_id, mocker):
     assert result is False
     fake_error.assert_called_with("ID out of range. Range is 1 to 3.")
 
-
 def test_all_save_state_no_output(mocker):
     mocker.patch("pygitgo.commands.state.git_stash_list", return_value="")
     mocker.patch("pygitgo.commands.state.info")
-
     result = all_save_state()
-
     assert result == []
 
-
 def test_all_save_state_with_output(mocker):
     output = (
         "stash@{0}||2023-10-27 10:00:00||Test stash\n"
@@ -59,7 +53,6 @@ def test_all_save_state_with_output(mocker):
         "stash_index": 0
     }
 
-
 def test_all_save_state_malformed_line(mocker):
     output = "malformed_line_here\nstash@{1}||2023-10-27 10:05:00||Another stash"
     mocker.patch("pygitgo.commands.state.git_stash_list", return_value=output)
@@ -71,7 +64,6 @@ def test_all_save_state_malformed_line(mocker):
     assert result[0]["message"] == "Another stash"
     fake_warning.assert_called_once_with("Skipping malformed line: malformed_line_here")
 
-
 def test_load_state_specific_id(mocker):
     save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
@@ -84,26 +76,21 @@ def test_load_state_specific_id(mocker):
     fake_apply.assert_called_once_with(stash_id="0")
     fake_success.assert_called_once_with("State 'msg' restored.")
 
-
 def test_load_state_invalid_id(mocker):
     save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
     mocker.patch("pygitgo.commands.state.validate_state_id", return_value=False)
 
-    from pygitgo.exceptions import GitGoError
     with pytest.raises(GitGoError):
         load_state("100")
 
-
 def test_load_state_invalid_argument(mocker):
     save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
 
-    from pygitgo.exceptions import GitGoError
     with pytest.raises(GitGoError):
         load_state("invalid_arg")
 
-
 def test_load_state_no_args(mocker):
     save_states = [
         {"id": 1, "ref": "stash@{1}", "date": "date", "message": "msg", "stash_index": 1},
@@ -119,7 +106,6 @@ def test_load_state_no_args(mocker):
     fake_apply.assert_called_once_with(stash_id="0")
     fake_success.assert_called_once_with("State 'msg2' restored.")
 
-
 def test_save_state_no_args(mocker):
     mocker.patch("pygitgo.commands.state.run_command", return_value="M file")
     fake_push = mocker.patch(
@@ -133,7 +119,6 @@ def test_save_state_no_args(mocker):
     fake_push.assert_called_once_with(label="Auto-Save")
     fake_success.assert_called_once_with("State 'Auto-Save' saved.")
 
-
 def test_save_state_with_name(mocker):
     mocker.patch("pygitgo.commands.state.run_command", return_value="M file")
     fake_push = mocker.patch(
@@ -147,9 +132,8 @@ def test_save_state_with_name(mocker):
     fake_push.assert_called_once_with(label="My-State")
     fake_success.assert_called_once_with("State 'My-State' saved.")
 
-
 def test_delete_state_all_confirm(mocker):
-    mocker.patch("builtins.input", return_value="y")
+    mocker.patch("pygitgo.commands.state.confirm", return_value=True)
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=[{"id": 1}])
     fake_clear = mocker.patch("pygitgo.commands.state.git_stash_clear", return_value=True)
     fake_success = mocker.patch("pygitgo.commands.state.success")
@@ -159,9 +143,8 @@ def test_delete_state_all_confirm(mocker):
     fake_clear.assert_called_once()
     fake_success.assert_called_once_with("All saved states deleted.")
 
-
 def test_delete_state_all_cancel(mocker):
-    mocker.patch("builtins.input", return_value="n")
+    mocker.patch("pygitgo.commands.state.confirm", return_value=False)
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=[{"id": 1}])
     fake_info = mocker.patch("pygitgo.commands.state.info")
 
@@ -169,15 +152,12 @@ def test_delete_state_all_cancel(mocker):
 
     fake_info.assert_called_once_with("Delete canceled.")
 
-
 def test_delete_state_invalid_id(mocker):
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=[{"id": 1}])
 
-    from pygitgo.exceptions import GitGoError
     with pytest.raises(GitGoError):
         delete_state("abc")
 
-
 def test_delete_state_specific_id(mocker):
     save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
     mocker.patch("pygitgo.commands.state.validate_state_id", return_value=True)
@@ -190,7 +170,6 @@ def test_delete_state_specific_id(mocker):
     fake_drop.assert_called_once_with(stash_id="0")
     fake_success.assert_called_once_with("State 1 deleted.")
 
-
 def test_delete_state_no_args(mocker):
     save_states = [
         {"id": 1, "ref": "stash@{1}", "date": "date", "message": "msg", "stash_index": 1},
@@ -206,7 +185,6 @@ def test_delete_state_no_args(mocker):
     fake_drop.assert_called_once_with(stash_id="0")
     fake_success.assert_called_once_with("State 2 deleted.")
 
-
 def test_load_state_keyboard_interrupt(mocker):
     save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
     mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
@@ -215,7 +193,6 @@ def test_load_state_keyboard_interrupt(mocker):
     fake_warning = mocker.patch("pygitgo.commands.state.warning")
     fake_success = mocker.patch("pygitgo.commands.state.success")
 
-    from pygitgo.commands.state import load_state
     with pytest.raises(SystemExit) as sys_exit:
         load_state("1")
 
@@ -224,86 +201,134 @@ def test_load_state_keyboard_interrupt(mocker):
     fake_run.assert_called_once_with(["git", "checkout", "--", "."])
     fake_success.assert_called_once_with("Partial changes cleaned up. Your stash is still saved.")
 
-
 def _state_args(action=None, action_alias=None, identifier=None, all=False):
     from argparse import Namespace
     return Namespace(action=action, action_alias=action_alias, identifier=identifier, all=all)
 
-
 def test_state_operation_list(mocker):
-    from pygitgo.commands.state import state_operation
     mock_list = mocker.patch("pygitgo.commands.state.state_list")
-
     state_operation(_state_args(action="list"))
-
     mock_list.assert_called_once()
 
-
 def test_state_operation_save_with_name(mocker):
-    from pygitgo.commands.state import state_operation
     mock_save = mocker.patch("pygitgo.commands.state.save_state")
-
     state_operation(_state_args(action="save", identifier="wip"))
-
     mock_save.assert_called_once_with("wip")
 
-
 def test_state_operation_load_with_id(mocker):
-    from pygitgo.commands.state import state_operation
     mock_load = mocker.patch("pygitgo.commands.state.load_state")
-
     state_operation(_state_args(action="load", identifier="2"))
-
     mock_load.assert_called_once_with("2")
 
-
 def test_state_operation_delete_with_id(mocker):
-    from pygitgo.commands.state import state_operation
     mock_delete = mocker.patch("pygitgo.commands.state.delete_state")
-
     state_operation(_state_args(action="delete", identifier="1"))
-
     mock_delete.assert_called_once_with("1")
 
-
 def test_state_operation_alias_list(mocker):
-    from pygitgo.commands.state import state_operation
     mock_list = mocker.patch("pygitgo.commands.state.state_list")
-
     state_operation(_state_args(action_alias="list"))
-
     mock_list.assert_called_once()
 
-
 def test_state_operation_delete_all_via_flag(mocker):
-    from pygitgo.commands.state import state_operation
     mock_delete = mocker.patch("pygitgo.commands.state.delete_state")
-
     state_operation(_state_args(action="delete", all=True))
-
     mock_delete.assert_called_once_with("-a")
 
-
 def test_state_operation_conflicting_actions():
-    from pygitgo.commands.state import state_operation
-    from pygitgo.exceptions import GitGoError
-
     with pytest.raises(GitGoError, match="Conflicting actions"):
         state_operation(_state_args(action="list", action_alias="save"))
 
-
 def test_state_operation_all_flag_requires_delete():
-    from pygitgo.commands.state import state_operation
-    from pygitgo.exceptions import GitGoError
-
     with pytest.raises(GitGoError, match="-a/--all flag is only valid"):
         state_operation(_state_args(action="list", all=True))
 
-
 def test_state_operation_missing_action():
-    from pygitgo.commands.state import state_operation
-    from pygitgo.exceptions import GitGoError
-
     with pytest.raises(GitGoError, match="Missing action"):
         state_operation(_state_args())
 
+def test_all_save_state_git_stash_list_exception(mocker):
+    mocker.patch("pygitgo.commands.state.git_stash_list", side_effect=GitCommandError(["cmd"]))
+    assert all_save_state() == []
+
+def test_display_save_states_empty(mocker):
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=[])
+    fake_info = mocker.patch("pygitgo.commands.state.info")
+    load_state()
+    fake_info.assert_called_once_with("No saved states to load.")
+
+def test_ask_state_id_q(mocker):
+    save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
+    mocker.patch("pygitgo.commands.state.confirm", return_value=True)
+    mocker.patch("builtins.input", return_value="q")
+    fake_info = mocker.patch("pygitgo.commands.state.info")
+    from pygitgo.commands.state import ask_state_id
+    assert ask_state_id(save_states) is None
+    fake_info.assert_called_once_with("Load canceled.", required=True)
+
+def test_load_state_stash_apply_false(mocker):
+    save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
+    mocker.patch("pygitgo.commands.state.validate_state_id", return_value=True)
+    mocker.patch("pygitgo.commands.state.git_stash_apply", return_value=False)
+    with pytest.raises(GitGoError, match="State load failed"):
+        load_state("1")
+
+def test_load_state_keyboard_interrupt_cleanup_fails(mocker):
+    save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
+    mocker.patch("pygitgo.commands.state.git_stash_apply", side_effect=KeyboardInterrupt)
+    mocker.patch("pygitgo.commands.state.run_command", side_effect=GitCommandError(["cmd"]))
+    fake_warning = mocker.patch("pygitgo.commands.state.warning")
+    with pytest.raises(SystemExit) as sys_exit:
+        load_state("1")
+    assert sys_exit.value.code == 130
+    fake_warning.assert_any_call("Could not clean up automatically. Run 'git status' to check, then 'git checkout -- .' if needed.")
+
+def test_save_state_local_changes_error(mocker):
+    mocker.patch("pygitgo.commands.state.run_command", side_effect=GitCommandError(["cmd"]))
+    fake_warning = mocker.patch("pygitgo.commands.state.warning")
+    save_state()
+    fake_warning.assert_called_once_with("Could not check for local changes - make sure you're in a valid git repository.")
+
+def test_save_state_no_changes(mocker):
+    mocker.patch("pygitgo.commands.state.run_command", return_value="")
+    fake_info = mocker.patch("pygitgo.commands.state.info")
+    save_state()
+    fake_info.assert_called_once_with("No local changes to save.")
+
+def test_save_state_push_fails(mocker):
+    mocker.patch("pygitgo.commands.state.run_command", return_value="M test.py")
+    mocker.patch("pygitgo.commands.state.git_stash_push", return_value=None)
+    fake_error = mocker.patch("pygitgo.commands.state.error")
+    save_state()
+    fake_error.assert_called_once_with("Failed to save state 'Auto-Save'.")
+
+def test_delete_state_empty(mocker):
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=[])
+    fake_info = mocker.patch("pygitgo.commands.state.info")
+    delete_state()
+    fake_info.assert_called_once_with("No saved states to delete.")
+
+def test_delete_state_clear_all_fails(mocker):
+    mocker.patch("pygitgo.commands.state.confirm", return_value=True)
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=[{"id": 1}])
+    mocker.patch("pygitgo.commands.state.git_stash_clear", return_value=False)
+    fake_error = mocker.patch("pygitgo.commands.state.error")
+    delete_state("-a")
+    fake_error.assert_called_once_with("Failed to delete all saved states.")
+
+def test_delete_state_specific_id_fails(mocker):
+    save_states = [{"id": 1, "ref": "stash@{0}", "date": "date", "message": "msg", "stash_index": 0}]
+    mocker.patch("pygitgo.commands.state.validate_state_id", return_value=True)
+    mocker.patch("pygitgo.commands.state.all_save_state", return_value=save_states)
+    mocker.patch("pygitgo.commands.state.git_stash_drop", return_value=False)
+    fake_error = mocker.patch("pygitgo.commands.state.error")
+    with pytest.raises(GitGoError, match="Delete failed"):
+        delete_state("1")
+    fake_error.assert_called_once_with("Failed to delete state 1.")
+
+def test_state_operation_unknown_action(mocker):
+    args = _state_args(action="unknown")
+    with pytest.raises(GitGoError, match="Unknown state operation"):
+        state_operation(args)