overkill 0.7.0__tar.gz → 0.8.0__tar.gz

{overkill-0.7.0 → overkill-0.8.0}/.overkillrc.example

@@ -17,6 +17,14 @@
 # Enable auto-commit of fixes (default: true)
 # AUTO_COMMIT=true
 
+# CI trigger policy for iteration commits (default: last-only)
+#   last-only — append "[skip ci]" to each iteration commit; push a single
+#               empty "chore: trigger CI" commit only when the loop ends
+#               with all_clear (saves CI cost on long iteration runs)
+#   every     — each iteration commit triggers CI (pre-0.3 behaviour)
+#   none      — append "[skip ci]"; no trigger commit (forks / CI-less repos)
+# CI_TRIGGER_MODE="last-only"
+
 # Path to active prompt templates (default: <script_dir>/../prompts/active)
 # PROMPTS_DIR="./custom-prompts"
 

{overkill-0.7.0 → overkill-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overkill
-Version: 0.7.0
+Version: 0.8.0
 Summary: AI-powered code review loop — automates Codex/Gemini review + Claude fix cycles
 Project-URL: Repository, https://github.com/modocai/mr-overkill
 Project-URL: Issues, https://github.com/modocai/mr-overkill/issues
@@ -125,6 +125,11 @@ Options:
   --no-auto-commit         Fix but do not commit/push (single iteration)
   --resume                 Resume from a previously interrupted run (reuses existing logs)
   --reviewer-backend <be>  Reviewer backend: claude|codex (default: codex)
+  --ci-trigger-mode <m>    CI trigger policy: every|last-only|none (default: last-only).
+                           'last-only' tags each iteration commit with [skip ci]
+                           and pushes a single empty trigger commit on PASS —
+                           CI runs once instead of once per iteration.
+                           Use 'every' to restore pre-0.3 per-commit CI.
   --diagnostic-log         Save full Claude event stream to sidecar files
 
 Examples:
@@ -134,6 +139,7 @@ Examples:
   overkill review-loop -n 3 --no-self-review # disable self-review sub-loop
   overkill review-loop --resume              # resume an interrupted run
   overkill review-loop -n 2 --reviewer-backend claude  # use Claude as reviewer
+  overkill review-loop -n 10 --ci-trigger-mode last-only  # CI fires once on PASS
 ```
 
 ## Usage: overkill refactor-suggest

{overkill-0.7.0 → overkill-0.8.0}/README.md

@@ -102,6 +102,11 @@ Options:
   --no-auto-commit         Fix but do not commit/push (single iteration)
   --resume                 Resume from a previously interrupted run (reuses existing logs)
   --reviewer-backend <be>  Reviewer backend: claude|codex (default: codex)
+  --ci-trigger-mode <m>    CI trigger policy: every|last-only|none (default: last-only).
+                           'last-only' tags each iteration commit with [skip ci]
+                           and pushes a single empty trigger commit on PASS —
+                           CI runs once instead of once per iteration.
+                           Use 'every' to restore pre-0.3 per-commit CI.
   --diagnostic-log         Save full Claude event stream to sidecar files
 
 Examples:
@@ -111,6 +116,7 @@ Examples:
   overkill review-loop -n 3 --no-self-review # disable self-review sub-loop
   overkill review-loop --resume              # resume an interrupted run
   overkill review-loop -n 2 --reviewer-backend claude  # use Claude as reviewer
+  overkill review-loop -n 10 --ci-trigger-mode last-only  # CI fires once on PASS
 ```
 
 ## Usage: overkill refactor-suggest

{overkill-0.7.0 → overkill-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "overkill"
-version = "0.7.0"
+version = "0.8.0"
 description = "AI-powered code review loop — automates Codex/Gemini review + Claude fix cycles"
 readme = "README.md"
 license = { text = "MIT" }

{overkill-0.7.0 → overkill-0.8.0}/src/mr_overkill/cli.py

@@ -108,7 +108,7 @@ def _load_rc_file(rc_name: str) -> dict[str, str]:
         "RETRY_INITIAL_WAIT", "BUDGET_SCOPE", "DIAGNOSTIC_LOG",
         "SCOPE", "AUTO_APPROVE", "CREATE_PR", "WITH_REVIEW",
         "REVIEW_LOOPS", "FIX_NITS", "REVIEWER_BACKEND",
-        "REVIEWER_CONTEXT",
+        "REVIEWER_CONTEXT", "CI_TRIGGER_MODE",
     }
     boolean_keys = {
         "DRY_RUN", "AUTO_COMMIT", "DIAGNOSTIC_LOG",
@@ -306,6 +306,18 @@ def parse_review_loop_args(
         default=None,
         help="Additional context for the reviewer (e.g. design intent, constraints)",
     )
+    parser.add_argument(
+        "--ci-trigger-mode",
+        default=None,
+        choices=["every", "last-only", "none"],
+        help=(
+            "CI trigger policy for iteration commits. "
+            "'last-only' (default): append [skip ci] to iteration commits and "
+            "push a single empty 'chore: trigger CI' commit only on PASS. "
+            "'every': every commit triggers CI. "
+            "'none': append [skip ci] with no trigger commit."
+        ),
+    )
 
     args = parser.parse_args(argv)
 
@@ -405,6 +417,10 @@ def parse_review_loop_args(
             saved = log_dir / "reviewer-context.txt"
             if saved.is_file():
                 args.context = saved.read_text().strip()
+        if args.ci_trigger_mode is None:
+            saved = log_dir / "ci-trigger-mode.txt"
+            if saved.is_file():
+                args.ci_trigger_mode = saved.read_text().strip()
 
     if max_loop is not None and max_loop < 1:
         parser.error("--max-loop must be a positive integer")
@@ -420,6 +436,17 @@ def parse_review_loop_args(
         args.context if args.context is not None else rc.get("REVIEWER_CONTEXT", "")
     )
 
+    ci_trigger_mode = (
+        args.ci_trigger_mode
+        if args.ci_trigger_mode is not None
+        else rc.get("CI_TRIGGER_MODE", "last-only")
+    )
+    if ci_trigger_mode not in ("every", "last-only", "none"):
+        parser.error(
+            f"CI_TRIGGER_MODE must be 'every', 'last-only', or 'none',"
+            f" got {ci_trigger_mode!r}"
+        )
+
     return LoopConfig(
         current_branch=current_branch,
         target_branch=target,
@@ -441,6 +468,7 @@ def parse_review_loop_args(
         pr_number=pr_number,
         reviewer_backend=reviewer_backend,
         reviewer_context=reviewer_context,
+        ci_trigger_mode=ci_trigger_mode,
     )
 
 
@@ -713,6 +741,7 @@ def parse_refactor_suggest_args(
         prompts_dir=prompts_dir,
         scope=scope,
         reviewer_backend=reviewer_backend,
+        ci_trigger_mode="every",
     )
 
     extra = _RefactorExtra(

{overkill-0.7.0 → overkill-0.8.0}/src/mr_overkill/git_ops.py

@@ -234,7 +234,12 @@ def commit_and_push(
 
     logger.info("Committed.")
 
-    # Push if upstream exists
+    _push_current_branch(branch=branch, cwd=cwd)
+    return True
+
+
+def _push_current_branch(branch: str = "", cwd: Path | None = None) -> None:
+    """Push the current branch, setting upstream on first push if needed."""
     upstream_check = _run(
         ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
         cwd=cwd,
@@ -244,7 +249,8 @@ def commit_and_push(
         if push_result.returncode != 0:
             raise RuntimeError(f"git push failed: {push_result.stderr.strip()}")
         logger.info("Pushed.")
-    elif branch:
+        return
+    if branch:
         remote_check = _run(["git", "remote"], cwd=cwd)
         remotes = remote_check.stdout.strip().splitlines()
         remote = "origin" if "origin" in remotes else (remotes[0] if remotes else "")
@@ -253,9 +259,40 @@ def commit_and_push(
             if push_result.returncode != 0:
                 raise RuntimeError(f"git push failed: {push_result.stderr.strip()}")
             logger.info("Pushed (upstream set).")
-        else:
-            logger.info("No upstream/remote set — skipping push.")
-    else:
-        logger.info("No upstream set — skipping push.")
+            return
+        logger.info("No upstream/remote set — skipping push.")
+        return
+    logger.info("No upstream set — skipping push.")
+
+
+def push_trigger_commit(branch: str = "", cwd: Path | None = None) -> bool:
+    """Push an empty ``chore: trigger CI`` commit.
+
+    Used by ``--ci-trigger-mode last-only`` to fire CI once after a run of
+    iteration commits that were each tagged with ``[skip ci]``. Returns
+    ``True`` on success, ``False`` if the empty commit could not be created
+    (e.g. repo has no HEAD yet). Raises ``RuntimeError`` if ``git push`` fails.
+
+    Idempotent: if HEAD already lacks ``[skip ci]`` (a prior call succeeded
+    locally but the push may not have reached the remote), skip creating
+    another empty commit and just retry the push.
+    """
+    head_msg = _run(["git", "log", "-1", "--pretty=%B"], cwd=cwd).stdout
+    if head_msg and "[skip ci]" not in head_msg:
+        logger.info("HEAD already triggers CI — retrying push only.")
+        _push_current_branch(branch=branch, cwd=cwd)
+        return True
 
+    result = _run(
+        ["git", "commit", "--allow-empty", "-m", "chore: trigger CI"],
+        cwd=cwd,
+    )
+    if result.returncode != 0:
+        logger.warning(
+            "trigger commit failed: %s",
+            result.stderr.strip() or result.stdout.strip(),
+        )
+        return False
+    logger.info("Created CI trigger commit.")
+    _push_current_branch(branch=branch, cwd=cwd)
     return True

{overkill-0.7.0 → overkill-0.8.0}/src/mr_overkill/loop_engine.py

@@ -218,10 +218,20 @@ def review_fix_loop(
         # Already-completed runs can short-circuit after branch validation
         if state.status == "completed":
             resolved_status = FinalStatus(state.prev_status or "max_iterations_reached")
+            # Re-attempt the CI trigger push: a prior run may have written
+            # the terminal summary but failed (or been interrupted) before
+            # pushing the trigger commit, leaving the remote on a [skip ci]
+            # commit. push_trigger_commit is idempotent.
+            needs_trigger = (
+                resolved_status == FinalStatus.ALL_CLEAR
+                and config.ci_trigger_mode in ("last-only", "none")
+                and _has_skipped_fix_commit(commit_pattern, log_dir, cwd)
+            )
             return LoopResult(
                 final_status=resolved_status,
                 iterations_run=0,
                 summary_path=_generate_summary_safe(config, resolved_status),
+                made_skipped_fix_commit=needs_trigger,
             )
 
         resume_from = state.resume_from
@@ -285,6 +295,14 @@ def review_fix_loop(
     allowed_stashed = False
     had_findings = False
     fix_committed = False
+    # On resume, prior iteration commits already exist; in last-only/none
+    # modes those carry [skip ci], so a final trigger commit is still needed
+    # even if no new fix commit is made in this process.
+    made_skipped_fix_commit = (
+        config.resume
+        and resume_from > 1
+        and config.ci_trigger_mode in ("last-only", "none")
+    )
 
     for i in range(1, config.max_loop + 1):
         logger.info("── Iteration %d / %d ──", i, config.max_loop)
@@ -489,8 +507,11 @@ def review_fix_loop(
 
             # j. Commit & push
             if config.auto_commit:
+                subject = f"{commit_pattern} {i} fixes"
+                if config.ci_trigger_mode in ("last-only", "none"):
+                    subject += " [skip ci]"
                 commit_msg = (
-                    f"{commit_pattern} {i} fixes\n\n"
+                    f"{subject}\n\n"
                     f"Auto-generated by review loop (iteration {i}/{config.max_loop})"
                 )
                 if self_review_summary:
@@ -509,6 +530,8 @@ def review_fix_loop(
                     final_status = FinalStatus.COMMIT_PUSH_ERROR
                     iterations_run = i
                     break
+                if fix_committed and config.ci_trigger_mode in ("last-only", "none"):
+                    made_skipped_fix_commit = True
             else:
                 logger.info("AUTO_COMMIT is disabled — skipping commit and push.")
         finally:
@@ -552,12 +575,37 @@ def review_fix_loop(
         final_status=final_status,
         iterations_run=iterations_run,
         summary_path=summary_path,
+        made_skipped_fix_commit=made_skipped_fix_commit,
     )
 
 
 # ── Private helpers ──────────────────────────────────────────────────
 
 
+def _has_skipped_fix_commit(
+    commit_pattern: str, log_dir: Path, cwd: Path | None
+) -> bool:
+    """Return True if any [skip ci] fix commit exists since the run started."""
+    start_file = log_dir / "start-commit.txt"
+    if not start_file.is_file():
+        return False
+    start = start_file.read_text().strip()
+    if not start:
+        return False
+    result = subprocess.run(
+        [
+            "git", "log", "--fixed-strings",
+            f"--grep={commit_pattern}", "--grep=[skip ci]", "--all-match",
+            "--oneline", f"{start}..HEAD",
+        ],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
 def _validate_target_branch(target: str, cwd: Path | None) -> bool:
     """Return True if *target* is a valid git ref."""
     result = subprocess.run(
@@ -636,6 +684,7 @@ def _save_metadata(config: LoopConfig, cwd: Path | None) -> None:
     (log_dir / "max-loop.txt").write_text(str(config.max_loop))
     (log_dir / "reviewer-backend.txt").write_text(config.reviewer_backend)
     (log_dir / "reviewer-context.txt").write_text(config.reviewer_context)
+    (log_dir / "ci-trigger-mode.txt").write_text(config.ci_trigger_mode)
     if config.scope:
         (log_dir / "scope.txt").write_text(config.scope)
 

{overkill-0.7.0 → overkill-0.8.0}/src/mr_overkill/models.py

@@ -162,6 +162,14 @@ class LoopConfig:
     resume: bool = False
     auto_approve: bool = False
 
+    # CI trigger policy for iteration commits:
+    #   "last-only" — default: append "[skip ci]" to iteration commits; push a
+    #                 single empty "chore: trigger CI" commit only on ALL_CLEAR.
+    #   "every"     — each commit triggers CI (pre-0.3 behaviour).
+    #   "none"      — append "[skip ci]" to iteration commits; never emit a
+    #                 trigger commit (forks / CI-less repos).
+    ci_trigger_mode: str = "last-only"
+
     # Retry / budget
     retry_max_wait: int = 7200
     retry_initial_wait: int = 30
@@ -193,6 +201,7 @@ class LoopResult:
     final_status: FinalStatus
     iterations_run: int
     summary_path: Path | None = None
+    made_skipped_fix_commit: bool = False
 
 
 # ── Protocols (DI contracts) ─────────────────────────────────────────

{overkill-0.7.0 → overkill-0.8.0}/src/mr_overkill/review_loop.py

@@ -9,6 +9,7 @@ from mr_overkill.agents import (
     create_review_agent,
     create_self_review_agent,
 )
+from mr_overkill.git_ops import push_trigger_commit
 from mr_overkill.loop_engine import review_fix_loop
 from mr_overkill.models import (
     FinalStatus,
@@ -42,6 +43,18 @@ def run(config: LoopConfig) -> int:
     if result.summary_path:
         logger.info("Summary: %s", result.summary_path)
 
+    if (
+        result.final_status == FinalStatus.ALL_CLEAR
+        and config.ci_trigger_mode == "last-only"
+        and config.auto_commit
+        and not config.dry_run
+        and result.made_skipped_fix_commit
+    ):
+        try:
+            push_trigger_commit(branch=config.current_branch)
+        except RuntimeError as exc:
+            logger.warning("Could not push CI trigger commit: %s", exc)
+
     success_statuses = {
         FinalStatus.ALL_CLEAR,
         FinalStatus.DRY_RUN,

{overkill-0.7.0 → overkill-0.8.0}/tests/test_cli.py

@@ -316,6 +316,100 @@ class TestParseReviewLoopArgs:
         ])
         assert config.reviewer_backend == "gemini"
 
+    @patch("mr_overkill.cli._detect_pr_number", return_value=None)
+    @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
+    @patch("mr_overkill.cli._load_rc_file", return_value={})
+    @patch("mr_overkill.cli.subprocess.run")
+    def test_ci_trigger_mode_default(
+        self,
+        mock_run: MagicMock,
+        mock_rc: MagicMock,
+        mock_branch: MagicMock,
+        mock_pr: MagicMock,
+    ) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="/tmp/repo")
+        config = parse_review_loop_args(["-n", "1"])
+        assert config.ci_trigger_mode == "last-only"
+
+    @patch("mr_overkill.cli._detect_pr_number", return_value=None)
+    @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
+    @patch("mr_overkill.cli._load_rc_file", return_value={})
+    @patch("mr_overkill.cli.subprocess.run")
+    def test_ci_trigger_mode_cli(
+        self,
+        mock_run: MagicMock,
+        mock_rc: MagicMock,
+        mock_branch: MagicMock,
+        mock_pr: MagicMock,
+    ) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="/tmp/repo")
+        config = parse_review_loop_args([
+            "-n", "1", "--ci-trigger-mode", "last-only",
+        ])
+        assert config.ci_trigger_mode == "last-only"
+
+    @patch("mr_overkill.cli._detect_pr_number", return_value=None)
+    @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
+    @patch(
+        "mr_overkill.cli._load_rc_file",
+        return_value={"CI_TRIGGER_MODE": "none"},
+    )
+    @patch("mr_overkill.cli.subprocess.run")
+    def test_ci_trigger_mode_rc(
+        self,
+        mock_run: MagicMock,
+        mock_rc: MagicMock,
+        mock_branch: MagicMock,
+        mock_pr: MagicMock,
+    ) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="/tmp/repo")
+        config = parse_review_loop_args(["-n", "1"])
+        assert config.ci_trigger_mode == "none"
+
+    @patch("mr_overkill.cli._detect_pr_number", return_value=None)
+    @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
+    @patch(
+        "mr_overkill.cli._load_rc_file",
+        return_value={"CI_TRIGGER_MODE": "none"},
+    )
+    @patch("mr_overkill.cli.subprocess.run")
+    def test_ci_trigger_mode_cli_overrides_rc(
+        self,
+        mock_run: MagicMock,
+        mock_rc: MagicMock,
+        mock_branch: MagicMock,
+        mock_pr: MagicMock,
+    ) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="/tmp/repo")
+        config = parse_review_loop_args([
+            "-n", "1", "--ci-trigger-mode", "every",
+        ])
+        assert config.ci_trigger_mode == "every"
+
+    @patch("mr_overkill.cli._detect_pr_number", return_value=None)
+    @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
+    @patch(
+        "mr_overkill.cli._load_rc_file",
+        return_value={"CI_TRIGGER_MODE": "bogus"},
+    )
+    @patch("mr_overkill.cli.subprocess.run")
+    def test_ci_trigger_mode_invalid_rc(
+        self,
+        mock_run: MagicMock,
+        mock_rc: MagicMock,
+        mock_branch: MagicMock,
+        mock_pr: MagicMock,
+    ) -> None:
+        mock_run.return_value = MagicMock(returncode=0, stdout="/tmp/repo")
+        with pytest.raises(SystemExit):
+            parse_review_loop_args(["-n", "1"])
+
+    def test_ci_trigger_mode_invalid_cli(self) -> None:
+        with pytest.raises(SystemExit):
+            parse_review_loop_args([
+                "-n", "1", "--ci-trigger-mode", "bogus",
+            ])
+
 
 class TestParseRefactorSuggestArgs:
     @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
@@ -336,6 +430,9 @@ class TestParseRefactorSuggestArgs:
         assert config.max_loop == 1
         assert extra.create_pr is False
         assert extra.with_review is False
+        # refactor-suggest does not push a trigger commit, so iteration
+        # commits must trigger CI directly — never inherit "last-only".
+        assert config.ci_trigger_mode == "every"
 
     @patch("mr_overkill.cli._detect_current_branch", return_value="feat/x")
     @patch("mr_overkill.cli._load_rc_file", return_value={})

{overkill-0.7.0 → overkill-0.8.0}/tests/test_git_ops.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
+from unittest.mock import MagicMock, patch
 
 from mr_overkill.git_ops import (
     changed_files_since_snapshot,
     diff_hash,
     gen_uuid,
     git_all_dirty,
+    push_trigger_commit,
     sha256,
     snapshot_worktree,
 )
@@ -126,3 +128,76 @@ class TestChangedFilesSinceSnapshot:
         )
         assert "src.txt" in changed
         assert not any(f.startswith("logs/") for f in changed)
+
+
+class TestPushTriggerCommit:
+    """Empty trigger commit used by ``--ci-trigger-mode last-only``."""
+
+    @patch("mr_overkill.git_ops._run")
+    def test_creates_empty_commit_and_pushes(self, mock_run: MagicMock) -> None:
+        # 1) HEAD message has [skip ci], 2) commit succeeds,
+        # 3) upstream check succeeds, 4) push succeeds
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout="fix: something [skip ci]\n", stderr=""),
+            MagicMock(returncode=0, stdout="", stderr=""),
+            MagicMock(returncode=0, stdout="origin/feat/x", stderr=""),
+            MagicMock(returncode=0, stdout="", stderr=""),
+        ]
+        assert push_trigger_commit() is True
+
+        commit_call = mock_run.call_args_list[1]
+        assert commit_call.args[0] == [
+            "git", "commit", "--allow-empty", "-m", "chore: trigger CI",
+        ]
+        push_call = mock_run.call_args_list[3]
+        assert push_call.args[0] == ["git", "push"]
+
+    @patch("mr_overkill.git_ops._run")
+    def test_commit_failure_returns_false_without_push(
+        self, mock_run: MagicMock,
+    ) -> None:
+        # HEAD has [skip ci]; then commit attempt fails — no push should follow.
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout="fix: something [skip ci]\n", stderr=""),
+            MagicMock(returncode=1, stdout="", stderr="nothing to commit"),
+        ]
+        assert push_trigger_commit() is False
+        assert mock_run.call_count == 2
+
+    @patch("mr_overkill.git_ops._run")
+    def test_sets_upstream_when_no_upstream_yet(
+        self, mock_run: MagicMock,
+    ) -> None:
+        # HEAD has [skip ci], commit ok, upstream check fails,
+        # remote check returns 'origin', push -u ok
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout="fix: x [skip ci]\n", stderr=""),
+            MagicMock(returncode=0, stdout="", stderr=""),
+            MagicMock(returncode=128, stdout="", stderr="no upstream"),
+            MagicMock(returncode=0, stdout="origin\n", stderr=""),
+            MagicMock(returncode=0, stdout="", stderr=""),
+        ]
+        assert push_trigger_commit(branch="feat/x") is True
+        push_call = mock_run.call_args_list[4]
+        assert push_call.args[0] == [
+            "git", "push", "-u", "origin", "feat/x",
+        ]
+
+    @patch("mr_overkill.git_ops._run")
+    def test_skips_extra_commit_when_head_already_triggers_ci(
+        self, mock_run: MagicMock,
+    ) -> None:
+        # HEAD lacks [skip ci] (trigger commit already exists from a prior
+        # run that failed before pushing); only the push should be retried.
+        mock_run.side_effect = [
+            MagicMock(returncode=0, stdout="chore: trigger CI\n", stderr=""),
+            MagicMock(returncode=0, stdout="origin/feat/x", stderr=""),
+            MagicMock(returncode=0, stdout="", stderr=""),
+        ]
+        assert push_trigger_commit() is True
+        # No new commit attempted; HEAD check + upstream check + push only.
+        assert mock_run.call_count == 3
+        assert mock_run.call_args_list[1].args[0] == [
+            "git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}",
+        ]
+        assert mock_run.call_args_list[2].args[0] == ["git", "push"]