claude-dev-env 8.98.7 → 8.98.9

package/scripts/Sync-RepoMain.ps1

@@ -8,9 +8,11 @@
   a remote, such as a read-only mirror kept current by a scheduled task.
 
   Safety rules:
-  - Only runs when the checked-out branch is the named branch
+  - Only runs when the checked-out branch is the named branch, unless
+    -Mirror is passed
   - Only runs when there are no tracked changes (untracked files are fine),
-    unless -StashDirty is passed
+    unless -StashDirty is passed. A -Mirror return stashes the tree the old
+    checkout left whatever -StashDirty says
   - Uses merge --ff-only (never force, never hard reset, never clean)
   - When the fast-forward fails because the files were already copied in,
     moves HEAD with a mixed reset, which writes no files. It keeps that move
@@ -42,6 +44,20 @@
   missing; when that pop also fails, the log names the stash entry so the
   operator can recover it by hand.
 
+.PARAMETER Mirror
+  Marks the tree as a mirror that must always sit on the named branch. With
+  the switch, a checkout found on another branch or a detached HEAD is moved
+  back: HEAD points at the local named branch again and a mixed reset moves
+  the index there. Every path that still holds the old checkout's content,
+  including files only the old checkout tracked, is stashed as "mirror
+  return <yyyy-MM-dd>: tree of <checkout> at <tip>", which puts the named
+  branch's files back. This stash runs with or without -StashDirty, because
+  a mirror's tree belongs to the named branch. The log names the checkout
+  and tip it left. A checkout with staged changes is skipped, so no staged
+  content is lost. When a step of the return fails, HEAD and the index go
+  back to the old checkout and the run exits 1. Without the switch, any
+  other checkout is skipped.
+
 .PARAMETER LogPath
   Absolute path to the run log (default: $HOME\.claude\logs\sync-repo-main.log).
 #>
@@ -52,6 +68,7 @@ param(
     [string]$Remote = 'origin',
     [string]$Branch = 'main',
     [switch]$StashDirty,
+    [switch]$Mirror,
     [string]$LogPath = (Join-Path $HOME '.claude\logs\sync-repo-main.log')
 )
 
@@ -131,6 +148,84 @@ function Invoke-GitOrExit {
     return $result.Output
 }
 
+function Invoke-MirrorReturn {
+    <#
+      Moves a mirror found on another branch or a detached HEAD back to the
+      named branch. HEAD and the index move first, then every path where the
+      tree still holds the old checkout's content is stashed, including files
+      only the old checkout tracked. Any failure puts HEAD and the index back
+      on the old checkout, so the next run meets the same state and tries again.
+    #>
+    param(
+        [Parameter(Mandatory)]
+        [AllowEmptyString()]
+        [string]$LeftBranch
+    )
+    $leftCheckoutName = if ($LeftBranch) { "branch '$LeftBranch'" } else { 'detached HEAD' }
+    $stagedResult = Invoke-Git -Arguments @('diff', '--cached', '--quiet')
+    if ($stagedResult.ExitCode -ne 0) {
+        Write-SyncLog -Level 'SKIP' -Message "mirror return refused: $leftCheckoutName has staged changes"
+        exit 3
+    }
+    $leftTip = Invoke-GitOrExit -Arguments @('rev-parse', 'HEAD') `
+        -FailureMessage 'cannot read the tip of the checkout being left' -FailureExitCode 2
+    $null = Invoke-GitOrExit -Arguments @('rev-parse', '--verify', '-q', "refs/heads/$Branch") `
+        -FailureMessage "mirror has no local $Branch branch to return to" -FailureExitCode 2
+    $leftOnlyResult = Invoke-Git -Arguments @('diff', '--name-only', '--no-renames', '-z', '--diff-filter=A', "refs/heads/$Branch", $leftTip)
+    if ($leftOnlyResult.ExitCode -ne 0) {
+        Write-SyncLog -Level 'ERROR' -Message "mirror return skipped: cannot list files only $leftCheckoutName tracks: $($leftOnlyResult.Output)"
+        exit 1
+    }
+    $null = Invoke-GitOrExit -Arguments @('symbolic-ref', 'HEAD', "refs/heads/$Branch") `
+        -FailureMessage "cannot point HEAD at $Branch" -FailureExitCode 1
+
+    $resetResult = Invoke-Git -Arguments @('reset', '-q')
+    $changedResult = if ($resetResult.ExitCode -eq 0) { Invoke-Git -Arguments @('diff', '--name-only', '--no-renames', '-z') } else { $resetResult }
+    $failure = if ($resetResult.ExitCode -ne 0) { "mixed reset onto $Branch failed: $($resetResult.Output)" }
+               elseif ($changedResult.ExitCode -ne 0) { "cannot list the tree left by $leftCheckoutName`: $($changedResult.Output)" }
+    $leftTreeNote = 'the tree already matched'
+    if (-not $failure) {
+        $allLeftPaths = [System.Collections.Generic.List[string]]::new()
+        foreach ($changedPath in Get-NulSeparatedPaths -Output $changedResult.Output) { $allLeftPaths.Add($changedPath) }
+        foreach ($leftOnlyPath in Get-NulSeparatedPaths -Output $leftOnlyResult.Output) {
+            if (Test-Path -LiteralPath (Join-Path $RepoPath $leftOnlyPath)) { $allLeftPaths.Add($leftOnlyPath) }
+        }
+        if ($allLeftPaths.Count -gt 0) {
+            $leftTreeStashMessage = 'mirror return {0}: tree of {1} at {2}' -f (Get-Date -Format 'yyyy-MM-dd'), $leftCheckoutName, $leftTip
+            $pathspecFile = $null
+            try {
+                $pathspecFile = New-TemporaryFile
+                $pathspecText = (($allLeftPaths | Select-Object -Unique | ForEach-Object { ":(literal)$_" }) -join "`0") + "`0"
+                [System.IO.File]::WriteAllText($pathspecFile.FullName, $pathspecText, [System.Text.UTF8Encoding]::new($false))
+                $stashResult = Invoke-Git -Arguments @('stash', 'push', '--all', '-m', $leftTreeStashMessage, "--pathspec-from-file=$($pathspecFile.FullName)", '--pathspec-file-nul')
+            }
+            catch {
+                $stashResult = [pscustomobject]@{ ExitCode = 1; Output = $_.Exception.Message }
+            }
+            finally {
+                if ($pathspecFile) {
+                    Remove-Item -LiteralPath $pathspecFile.FullName -Force -ErrorAction SilentlyContinue
+                }
+            }
+            if ($stashResult.ExitCode -ne 0) {
+                $failure = "stashing the tree of $leftCheckoutName failed: $($stashResult.Output)"
+            }
+            else {
+                $leftTreeNote = "its tree is stashed as '$leftTreeStashMessage'"
+            }
+        }
+    }
+    if ($failure) {
+        $restoreArguments = if ($LeftBranch) { @('symbolic-ref', 'HEAD', "refs/heads/$LeftBranch") } else { @('update-ref', '--no-deref', 'HEAD', $leftTip) }
+        $restoreResult = Invoke-Git -Arguments $restoreArguments
+        $indexResult = if ($resetResult.ExitCode -eq 0) { Invoke-Git -Arguments @('reset', '-q') } else { $restoreResult }
+        $restoreNote = if ($restoreResult.ExitCode -eq 0 -and $indexResult.ExitCode -eq 0) { "HEAD and index are back on $leftCheckoutName at $leftTip" } else { "putting HEAD back on $leftCheckoutName at $leftTip also failed: $($restoreResult.Output) $($indexResult.Output)" }
+        Write-SyncLog -Level 'ERROR' -Message "mirror return failed, $failure; $restoreNote"
+        exit 1
+    }
+    Write-SyncLog -Level 'MIRROR' -Message "left $leftCheckoutName at $leftTip; HEAD is on $Branch and $leftTreeNote"
+}
+
 function Get-NulSeparatedPaths {
     param(
         [Parameter(Mandatory)]
@@ -229,8 +324,11 @@ try {
     $currentBranch = Invoke-GitOrExit -Arguments @('branch', '--show-current') `
         -FailureMessage 'cannot read current branch' -FailureExitCode 2
     if ($currentBranch -ne $Branch) {
-        Write-SyncLog -Level 'SKIP' -Message "checkout is '$currentBranch', not '$Branch' (remote=$Remote)"
-        exit 3
+        if (-not $Mirror) {
+            Write-SyncLog -Level 'SKIP' -Message "checkout is '$currentBranch', not '$Branch' (remote=$Remote)"
+            exit 3
+        }
+        Invoke-MirrorReturn -LeftBranch $currentBranch
     }
 
     $statusOutput = Invoke-GitOrExit -Arguments @('status', '--porcelain') `

package/scripts/account_broker.py

@@ -168,6 +168,11 @@ def _mark_spent(all_state: dict[str, object], reading: Reading, now: datetime) -
     return until
 
 
+def _is_no_roster_name_beside_a_roster(product: Product, name: str, all_readings: Sequence[Reading]) -> bool:
+    all_roster_names = {each_reading.account.name for each_reading in all_readings}
+    return product is Product.CODEX and bool(all_roster_names) and name == NO_ROSTER_ACCOUNT_NAME and name not in all_roster_names
+
+
 def _outside_roster_resets(product: Product, all_readings: Sequence[Reading], all_state: Mapping[str, object], now: datetime) -> dict[str, datetime]:
     marks = all_state.get("spent") if isinstance(all_state.get("spent"), dict) else {}
     all_roster_names = {each_reading.account.name for each_reading in all_readings}
@@ -178,7 +183,7 @@ def _outside_roster_resets(product: Product, all_readings: Sequence[Reading], al
             continue
         name = each_key[len(prefix):-len(placeholder_suffix)]
         reset = _stored_reset(each_raw, now)
-        if name not in all_roster_names and reset is not None:
+        if name not in all_roster_names and reset is not None and not _is_no_roster_name_beside_a_roster(product, name, all_readings):
             all_resets_by_name[name] = reset
     return all_resets_by_name
 
@@ -395,13 +400,16 @@ def _save_spent_arguments(all_marks: Sequence[str], all_readings: Sequence[Readi
     all_accounts_by_profile = {each_reading.account.profile: each_reading for each_reading in all_readings if each_reading.account.profile}
     all_accounts_by_name = all_accounts_by_profile | {each_reading.account.name: each_reading for each_reading in all_readings}
     all_parsed_marks = [_parse_spent_mark(all_accounts_by_name, each_mark, product) for each_mark in all_marks]
-    for each_reading, each_reset in all_parsed_marks:
+    all_saved_marks = [each_mark for each_mark in all_parsed_marks if not _is_no_roster_name_beside_a_roster(product, each_mark[0].account.name, all_readings)]
+    for each_reading, each_reset in all_saved_marks:
         _record_spent(all_state, each_reading, now, each_reset)
-    if all_parsed_marks:
+    if all_saved_marks:
         _save_state(broker_state_path(), all_state)
     for each_reading, _ in all_parsed_marks:
         name = each_reading.account.name
-        if name not in all_accounts_by_name and (all_accounts_by_name or name != NO_ROSTER_ACCOUNT_NAME):
+        if _is_no_roster_name_beside_a_roster(product, name, all_readings):
+            print(f"warning: spent mark names {name}, the home used only with no roster, so it is outside the roster; choose ignores it", file=sys.stderr)
+        elif name not in all_accounts_by_name and (all_accounts_by_name or name != NO_ROSTER_ACCOUNT_NAME):
             print(f"warning: spent mark names {name}, an account outside the roster; choose waits until its reset", file=sys.stderr)
 
 

package/scripts/test_account_broker.py

@@ -947,6 +947,41 @@ def test_should_wait_for_spent_default_home_until_the_mark_passes(
     assert running_decision["home"] == str(home.resolve())
 
 
+def test_should_run_on_a_roster_account_while_a_no_roster_default_mark_is_live(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("personal")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"personal": _meters(99, 99)}))
+    _freeze_clock(monkeypatch, NOW)
+    no_roster_account = Account(Product.CODEX, "default", Path(), False)
+    account_broker._save_state(
+        account_broker.broker_state_path(),
+        {"meters": {}, "spent": {account_broker._state_key(no_roster_account): (NOW + timedelta(hours=1)).timestamp()}, "affinity": {}},
+    )
+
+    code = account_broker.main(("choose", "--product", "codex"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["action"] == "run"
+    assert decision["account"] == "personal"
+
+
+def test_should_not_save_a_default_spent_mark_while_a_roster_exists(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account = _account("personal")
+    monkeypatch.setitem(account_broker.all_product_adapters, Product.CODEX, _adapter((account,), {"personal": _meters(99, 99)}))
+    _freeze_clock(monkeypatch, NOW)
+
+    code = account_broker.main(("choose", "--product", "codex", "--spent", "default"))
+
+    decision = json.loads(capsys.readouterr().out)["decision"]
+    assert code == 0
+    assert decision["account"] == "personal"
+    assert account_broker._load_state(account_broker.broker_state_path())["spent"] == {}
+
+
 def test_should_keep_a_spent_mark_without_a_reset_for_one_hour(
     monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:

package/scripts/tests/Sync-RepoMain.Tests.ps1

@@ -68,9 +68,52 @@ BeforeAll {
         & pwsh -NoProfile -File $scriptUnderTest -RepoPath $Fixture.MirrorPath -StashDirty -LogPath $Fixture.LogPath | Out-Null
         return $LASTEXITCODE
     }
+
+    function Invoke-MirrorSyncScript {
+        param([pscustomobject]$Fixture)
+        & pwsh -NoProfile -File $scriptUnderTest -RepoPath $Fixture.MirrorPath -StashDirty -Mirror -LogPath $Fixture.LogPath | Out-Null
+        return $LASTEXITCODE
+    }
+
+    function Switch-MirrorToFeatureBranch {
+        <#
+          Leaves the mirror on a feature branch whose commit edits tracked.txt,
+          the way a session that checked out a pull request in the mirror does.
+        #>
+        param([pscustomobject]$Fixture)
+        Invoke-TestGit -RepoPath $Fixture.MirrorPath -Arguments @('switch', '-q', '-c', 'feature') | Out-Null
+        Write-TestFile -RepoPath $Fixture.MirrorPath -RelativePath 'tracked.txt' -Content "feature`n"
+        Invoke-TestGit -RepoPath $Fixture.MirrorPath -Arguments @('commit', '-q', '-am', 'feature edit') | Out-Null
+        return Invoke-TestGit -RepoPath $Fixture.MirrorPath -Arguments @('rev-parse', 'HEAD')
+    }
 }
 
 Describe 'Sync-RepoMain' {
+    It 'skips a mirror left on another branch when -Mirror is absent' {
+        $fixture = New-MirrorBehindRemote -Name 'feature-no-mirror'
+        $featureTip = Switch-MirrorToFeatureBranch -Fixture $fixture
+
+        $exitCode = Invoke-SyncScript -Fixture $fixture
+
+        $exitCode | Should -Be 3
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('rev-parse', 'HEAD')) | Should -Be $featureTip
+    }
+
+    It 'returns a mirror left on another branch to main and fast-forwards it with -Mirror' {
+        $fixture = New-MirrorBehindRemote -Name 'feature-mirror'
+        $featureTip = Switch-MirrorToFeatureBranch -Fixture $fixture
+
+        $exitCode = Invoke-MirrorSyncScript -Fixture $fixture
+
+        $exitCode | Should -Be 0
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('branch', '--show-current')) | Should -Be 'main'
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('rev-parse', 'HEAD')) | Should -Be $fixture.RemoteTip
+        [System.IO.File]::ReadAllText((Join-Path $fixture.MirrorPath 'tracked.txt')) | Should -Be "new`n"
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('status', '--porcelain')) | Should -BeNullOrEmpty
+        (Invoke-TestGit -RepoPath $fixture.MirrorPath -Arguments @('rev-parse', 'feature')) | Should -Be $featureTip
+        (Get-Content -LiteralPath $fixture.LogPath -Raw) | Should -Match "left branch 'feature' at $featureTip"
+    }
+
     It 'fast-forwards a clean mirror that is behind the remote' {
         $fixture = New-MirrorBehindRemote -Name 'clean-behind'
 

package/scripts/tests/test_sync_repo_main_mirror.py

@@ -0,0 +1,226 @@
+"""Specifications for Sync-RepoMain returning a mirror left on another branch."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+_SCRIPT_PATH = Path(__file__).resolve().parents[1] / "Sync-RepoMain.ps1"
+_PWSH = shutil.which("pwsh") or "pwsh"
+_SKIPPED_EXIT_CODE = 3
+_SUCCESS_EXIT_CODE = 0
+_FAILURE_EXIT_CODE = 1
+
+
+def _git(repository_path: Path, *arguments: str) -> str:
+    completed = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_path),
+            "-c",
+            "user.name=tester",
+            "-c",
+            "user.email=tester@example.com",
+            "-c",
+            "core.autocrlf=false",
+            *arguments,
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def _mirror_on_feature_branch_behind_remote(
+    root_path: Path, should_advance_remote: bool = True
+) -> tuple[Path, str, str]:
+    remote_path = root_path / "remote.git"
+    author_path = root_path / "author"
+    mirror_path = root_path / "mirror"
+    remote_path.mkdir()
+    author_path.mkdir()
+    _git(remote_path, "init", "-q", "--bare", "-b", "main")
+    _git(author_path, "init", "-q", "-b", "main")
+    (author_path / "tracked.txt").write_text("old\n", encoding="utf-8")
+    _git(author_path, "add", "-A")
+    _git(author_path, "commit", "-q", "-m", "first")
+    _git(author_path, "remote", "add", "origin", str(remote_path))
+    _git(author_path, "push", "-q", "origin", "main")
+    subprocess.run(
+        [
+            "git",
+            "-c",
+            "core.autocrlf=false",
+            "clone",
+            "-q",
+            str(remote_path),
+            str(mirror_path),
+        ],
+        check=True,
+    )
+    _git(mirror_path, "config", "core.autocrlf", "false")
+    _git(mirror_path, "switch", "-q", "-c", "feature")
+    (mirror_path / "tracked.txt").write_text("feature\n", encoding="utf-8")
+    _git(mirror_path, "commit", "-q", "-am", "feature edit")
+    feature_tip = _git(mirror_path, "rev-parse", "HEAD")
+    if should_advance_remote:
+        (author_path / "tracked.txt").write_text("new\n", encoding="utf-8")
+        _git(author_path, "commit", "-q", "-am", "second")
+        _git(author_path, "push", "-q", "origin", "main")
+    remote_tip = _git(author_path, "rev-parse", "HEAD")
+    return mirror_path, feature_tip, remote_tip
+
+
+def _run_sync(mirror_path: Path, log_path: Path, *switches: str) -> int:
+    completed = subprocess.run(
+        [
+            _PWSH,
+            "-NoProfile",
+            "-File",
+            str(_SCRIPT_PATH),
+            "-RepoPath",
+            str(mirror_path),
+            *switches,
+            "-LogPath",
+            str(log_path),
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return completed.returncode
+
+
+def test_should_skip_a_feature_branch_checkout_without_mirror(tmp_path: Path) -> None:
+    mirror_path, feature_tip, _ = _mirror_on_feature_branch_behind_remote(tmp_path)
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-StashDirty") == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "branch", "--show-current") == "feature"
+    assert _git(mirror_path, "rev-parse", "HEAD") == feature_tip
+
+
+def test_should_return_a_feature_branch_checkout_to_main_with_mirror(
+    tmp_path: Path,
+) -> None:
+    mirror_path, feature_tip, remote_tip = _mirror_on_feature_branch_behind_remote(
+        tmp_path
+    )
+    log_path = tmp_path / "sync.log"
+
+    assert (
+        _run_sync(mirror_path, log_path, "-StashDirty", "-Mirror")
+        == _SUCCESS_EXIT_CODE
+    )
+    assert _git(mirror_path, "branch", "--show-current") == "main"
+    assert _git(mirror_path, "rev-parse", "HEAD") == remote_tip
+    assert (mirror_path / "tracked.txt").read_text(encoding="utf-8") == "new\n"
+    assert _git(mirror_path, "status", "--porcelain") == ""
+    assert _git(mirror_path, "rev-parse", "feature") == feature_tip
+    assert f"left branch 'feature' at {feature_tip}" in log_path.read_text(
+        encoding="utf-8"
+    )
+
+
+def test_should_restore_main_files_when_main_is_already_current(
+    tmp_path: Path,
+) -> None:
+    mirror_path, feature_tip, remote_tip = _mirror_on_feature_branch_behind_remote(
+        tmp_path, should_advance_remote=False
+    )
+    log_path = tmp_path / "sync.log"
+
+    assert (
+        _run_sync(mirror_path, log_path, "-StashDirty", "-Mirror")
+        == _SUCCESS_EXIT_CODE
+    )
+    assert _git(mirror_path, "rev-parse", "HEAD") == remote_tip
+    assert (mirror_path / "tracked.txt").read_text(encoding="utf-8") == "old\n"
+    assert _git(mirror_path, "status", "--porcelain") == ""
+    assert f"tree of branch 'feature' at {feature_tip}" in _git(
+        mirror_path, "stash", "list"
+    )
+
+
+def test_should_return_to_main_without_stash_dirty(tmp_path: Path) -> None:
+    mirror_path, _, remote_tip = _mirror_on_feature_branch_behind_remote(tmp_path)
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _SUCCESS_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == remote_tip
+    assert _git(mirror_path, "status", "--porcelain") == ""
+
+
+def test_should_name_a_detached_head_it_leaves(tmp_path: Path) -> None:
+    mirror_path, feature_tip, remote_tip = _mirror_on_feature_branch_behind_remote(
+        tmp_path
+    )
+    _git(mirror_path, "switch", "-q", "--detach", feature_tip)
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _SUCCESS_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == remote_tip
+    assert f"left detached HEAD at {feature_tip}" in log_path.read_text(
+        encoding="utf-8"
+    )
+
+
+def test_should_stash_a_file_only_the_left_checkout_tracks(tmp_path: Path) -> None:
+    mirror_path, _, remote_tip = _mirror_on_feature_branch_behind_remote(tmp_path)
+    (mirror_path / "feature-only.txt").write_text("feature only\n", encoding="utf-8")
+    _git(mirror_path, "add", "feature-only.txt")
+    _git(mirror_path, "commit", "-q", "-m", "feature-only file")
+    (mirror_path / "local-note.txt").write_text("untracked note\n", encoding="utf-8")
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _SUCCESS_EXIT_CODE
+    assert _git(mirror_path, "rev-parse", "HEAD") == remote_tip
+    assert not (mirror_path / "feature-only.txt").exists()
+    assert (mirror_path / "local-note.txt").exists()
+    assert _git(mirror_path, "status", "--porcelain") == "?? local-note.txt"
+
+
+def test_should_stash_a_left_file_that_main_ignores(tmp_path: Path) -> None:
+    mirror_path, _, _ = _mirror_on_feature_branch_behind_remote(tmp_path)
+    (mirror_path / "build.out").write_text("feature build\n", encoding="utf-8")
+    _git(mirror_path, "add", "build.out")
+    _git(mirror_path, "commit", "-q", "-m", "feature build output")
+    (mirror_path / ".git" / "info" / "exclude").write_text(
+        "build.out\n", encoding="utf-8"
+    )
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _SUCCESS_EXIT_CODE
+    assert not (mirror_path / "build.out").exists()
+    assert "tree of branch 'feature'" in _git(mirror_path, "stash", "list")
+
+
+def test_should_put_head_back_when_the_return_cannot_reset(tmp_path: Path) -> None:
+    mirror_path, feature_tip, _ = _mirror_on_feature_branch_behind_remote(tmp_path)
+    lock_path = mirror_path / ".git" / "index.lock"
+    lock_path.write_text("", encoding="utf-8")
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _FAILURE_EXIT_CODE
+    assert _git(mirror_path, "branch", "--show-current") == "feature"
+    assert _git(mirror_path, "rev-parse", "HEAD") == feature_tip
+    assert "HEAD and index are back on branch 'feature'" in log_path.read_text(
+        encoding="utf-8"
+    )
+    lock_path.unlink()
+    assert _git(mirror_path, "status", "--porcelain") == ""
+
+
+def test_should_skip_a_checkout_with_staged_changes(tmp_path: Path) -> None:
+    mirror_path, feature_tip, _ = _mirror_on_feature_branch_behind_remote(tmp_path)
+    (mirror_path / "tracked.txt").write_text("staged\n", encoding="utf-8")
+    _git(mirror_path, "add", "tracked.txt")
+    log_path = tmp_path / "sync.log"
+
+    assert _run_sync(mirror_path, log_path, "-Mirror") == _SKIPPED_EXIT_CODE
+    assert _git(mirror_path, "branch", "--show-current") == "feature"
+    assert _git(mirror_path, "rev-parse", "HEAD") == feature_tip
+    assert _git(mirror_path, "diff", "--cached", "--name-only") == "tracked.txt"