kiwi-code 0.0.43__tar.gz → 0.0.431__tar.gz

{kiwi_code-0.0.43 → kiwi_code-0.0.431}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.43
+Version: 0.0.431
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.43 → kiwi_code-0.0.431}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.43"
+version = "0.0.431"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.43 → kiwi_code-0.0.431}/src/kiwi_tui/main.py

@@ -1109,6 +1109,20 @@ def main() -> int:
         action="store_true",
         help="Run Kiwi in plain terminal mode instead of launching the full-screen TUI.",
     )
+    parser.add_argument(
+        "-w",
+        "--worktree",
+        "-worktree",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="NAME",
+        help=(
+            "Create (or reuse) an isolated git worktree under .kiwi/worktrees/NAME "
+            "and run Kiwi inside it. If NAME is omitted, Kiwi generates one."
+        ),
+    )
+
     parser.add_argument("--action-id", default=None, help="Start a fresh conversation for a specific action.")
     parser.add_argument("--run-id", default=None, help="Continue an existing run.")
     parser.add_argument(
@@ -1126,6 +1140,29 @@ def main() -> int:
 
     args = parser.parse_args(argv)
 
+    if getattr(args, "worktree", None) is not None:
+        try:
+            from kiwi_tui.worktrees import WorktreeError, ensure_worktree
+
+            worktree_name = str(getattr(args, "worktree", "") or "").strip() or None
+            worktree_path, _branch = ensure_worktree(worktree_name)
+            if not worktree_path.exists():
+                raise WorktreeError(
+                    f"Worktree directory does not exist after creation: {worktree_path}",
+                    hint="Run `git worktree prune` and retry, or choose a different worktree name.",
+                )
+            os.chdir(str(worktree_path))
+        except WorktreeError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+        except Exception as e:
+            print(
+                f"Error: Unexpected error while creating/entering the worktree: {e}",
+                file=sys.stderr,
+            )
+            return 1
+
+
     runtime_args = _build_runtime_args(args)
     if args.terminal:
         return run_terminal_mode(

kiwi_code-0.0.431/src/kiwi_tui/worktrees.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import re
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Sequence
+
+from wonderwords import RandomWord
+
+
+class WorktreeError(RuntimeError):
+    """User-facing error for `kiwi --worktree` failures.
+
+    Note: do NOT use a frozen dataclass here — Python sets exception traceback
+    attributes during propagation, and frozen dataclasses can break that.
+    """
+
+    def __init__(self, message: str, *, details: str | None = None, hint: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details
+        self.hint = hint
+
+    def __str__(self) -> str:  # pragma: no cover (formatting is stable)
+        parts: list[str] = [str(self.message or "").strip()]
+        if self.details:
+            parts.append(str(self.details).strip())
+        if self.hint:
+            parts.append(f"Hint: {str(self.hint).strip()}")
+        return "\n".join(part for part in parts if part)
+
+def generate_worktree_name() -> str:
+    """Generate a worktree name similar to Claude Code (adj-verb-noun)."""
+
+    try:
+        r = RandomWord()
+        adjective = r.word(include_parts_of_speech=["adjectives"]) or "bright"
+        verb = r.word(include_parts_of_speech=["verbs"]) or "running"
+        noun = r.word(include_parts_of_speech=["nouns"]) or "fox"
+        return f"{adjective}-{verb}-{noun}".lower().replace(" ", "-")
+    except Exception:
+        # Safety fallback: no external data / unexpected packaging issues.
+        return "bright-running-fox"
+
+
+def ensure_worktree(name: str | None, *, cwd: Path | None = None) -> tuple[Path, str]:
+    """Ensure a worktree exists under <repo>/.kiwi/worktrees/<name>.
+
+    Returns (worktree_path, branch_name).
+
+    Behavior mirrors Claude Code's `--worktree` defaults as closely as possible,
+    except we use the provided NAME as the branch name directly:
+    - Worktree directory: .kiwi/worktrees/<name>/ at repo root
+    - Branch name: <name>
+    - Base ref: origin/HEAD if `git fetch origin` succeeds, else local HEAD
+    """
+
+    if not shutil.which("git"):
+        raise WorktreeError(
+            "Unable to create worktree because `git` was not found on PATH.",
+            hint="Install Git and ensure the `git` command is available.",
+        )
+
+    start_cwd = Path(cwd or os.getcwd())
+    root_proc = _run_git(["rev-parse", "--show-toplevel"], cwd=start_cwd, check=False)
+    if root_proc.returncode != 0:
+        stderr = (root_proc.stderr or "").strip()
+        raise WorktreeError(
+            "Worktree mode requires running inside a git repository.",
+            details=stderr or None,
+            hint="Run `kiwi -w <name>` from within a git checkout.",
+        )
+    repo_root = (root_proc.stdout or "").strip()
+    if not repo_root:
+        raise WorktreeError("Unable to locate the git repository root.")
+
+    repo_root_path = Path(repo_root)
+    worktrees_root = repo_root_path / ".kiwi" / "worktrees"
+    try:
+        worktrees_root.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise WorktreeError(
+            f"Unable to create worktree root directory at {worktrees_root}.",
+            details=str(e),
+        )
+
+    if not name:
+        name = generate_worktree_name()
+
+    worktree_path = (worktrees_root / name).resolve()
+    _assert_within_dir(worktree_path, worktrees_root.resolve())
+
+    # If already registered as a git worktree, re-use.
+    # (Guard against stale worktree metadata: the path can exist in `git worktree list`
+    # even if the directory was deleted manually.)
+    existing = _list_worktree_paths(repo_root_path)
+    existing = _list_worktree_paths(repo_root_path)
+    if any(p.resolve() == worktree_path for p in existing):
+        if worktree_path.exists():
+            if not worktree_path.is_dir():
+                raise WorktreeError(
+                    f"Worktree path exists but is not a directory: {worktree_path}",
+                )
+            current_branch = _current_branch(worktree_path)
+            if current_branch != name:
+                pretty_current = current_branch if current_branch != "HEAD" else "(detached HEAD)"
+                raise WorktreeError(
+                    f"Worktree folder {worktree_path} is currently on branch {pretty_current}, expected {name}.",
+                    hint="Switch the worktree back to the expected branch, or choose a different -w name.",
+                )
+            return worktree_path, name
+        # Worktree is registered but missing on disk. Prune and retry once.
+        _run_git(["worktree", "prune"], cwd=repo_root_path, check=False)
+        existing = _list_worktree_paths(repo_root_path)
+        if any(p.resolve() == worktree_path for p in existing):
+            raise WorktreeError(
+                f"Worktree is registered with git but missing on disk: {worktree_path}",
+                hint="Run `git worktree prune` (or `git worktree remove <path>`) then re-run kiwi -w.",
+            )
+    if worktree_path.exists():
+        raise WorktreeError(
+            f"Worktree directory already exists but is not registered with git: {worktree_path}",
+            hint="Remove the directory or choose a different worktree name.",
+        )
+
+    # Claude Code branches from origin/HEAD if fetch succeeds.
+    base_ref = "HEAD"
+    fetch = _run_git(["fetch", "origin"], cwd=repo_root_path, check=False)
+    if fetch.returncode == 0:
+        verify = _run_git(["rev-parse", "--verify", "origin/HEAD"], cwd=repo_root_path, check=False)
+        if verify.returncode == 0:
+            base_ref = "origin/HEAD"
+
+    # Ensure we have at least one commit.
+    head_verify = _run_git(["rev-parse", "--verify", "HEAD"], cwd=repo_root_path, check=False)
+    if head_verify.returncode != 0:
+        raise WorktreeError(
+            "This repository has no commits yet, so a worktree cannot be created.",
+            hint="Create an initial commit (e.g. add a README and commit) and try again.",
+        )
+
+    branch = name
+    branch_exists = (
+        _run_git(["show-ref", "--verify", f"refs/heads/{branch}"], cwd=repo_root_path, check=False).returncode
+        == 0
+    )
+
+    add_cmd: list[str]
+    if branch_exists:
+        add_cmd = ["worktree", "add", str(worktree_path), branch]
+    else:
+        # If a remote branch exists (common case), create a local tracking branch from it.
+        remote_ref = f"refs/remotes/origin/{branch}"
+        remote_exists = (
+            _run_git(["show-ref", "--verify", remote_ref], cwd=repo_root_path, check=False).returncode == 0
+        )
+        if remote_exists:
+            add_cmd = [
+                "worktree",
+                "add",
+                "--track",
+                "-b",
+                branch,
+                str(worktree_path),
+                f"origin/{branch}",
+            ]
+        else:
+            add_cmd = ["worktree", "add", str(worktree_path), "-b", branch, base_ref]
+
+    add_proc = _run_git(add_cmd, cwd=repo_root_path, check=False)
+
+    if add_proc.returncode != 0:
+        stderr = (add_proc.stderr or "").strip()
+        stdout = (add_proc.stdout or "").strip()
+
+        # Auto-heal stale worktree metadata if git claims the branch is checked out
+        # at a missing Kiwi-managed worktree path.
+        stale_path = _extract_stale_checked_out_path(stderr) if stderr else None
+        if stale_path:
+            stale = Path(stale_path)
+            kiwi_root = (repo_root_path / ".kiwi" / "worktrees").resolve()
+            if not stale.exists():
+                try:
+                    stale_resolved = stale.resolve()
+                except Exception:
+                    stale_resolved = stale
+                try:
+                    stale_resolved.relative_to(kiwi_root)
+                    is_kiwi_managed = True
+                except Exception:
+                    is_kiwi_managed = False
+                if is_kiwi_managed:
+                    _run_git(["worktree", "prune"], cwd=repo_root_path, check=False)
+                    add_proc = _run_git(add_cmd, cwd=repo_root_path, check=False)
+                    if add_proc.returncode == 0:
+                        return worktree_path, branch
+                    stderr = (add_proc.stderr or "").strip()
+                    stdout = (add_proc.stdout or "").strip()
+
+        details = "\n".join(part for part in [stderr, stdout] if part) or None
+        hint = None
+        if stderr and ("is already checked out at" in stderr or "used by worktree at" in stderr):
+            hint = (
+                "That branch is already checked out in another worktree. "
+                "Choose a different branch name, or remove the other worktree (git worktree list/remove)."
+            )
+        raise WorktreeError(
+            f"Unable to create the git worktree at {worktree_path}.",
+            details=details,
+            hint=hint,
+        )
+
+    return worktree_path, branch
+
+
+def _assert_within_dir(path: Path, root: Path) -> None:
+    try:
+        path.relative_to(root)
+    except Exception:
+        raise WorktreeError(
+            f"Invalid worktree name/path resolved outside {root}: {path}",
+            hint="Avoid using '..' or absolute paths in the worktree name.",
+        )
+
+
+
+def _extract_stale_checked_out_path(stderr: str) -> str | None:
+    """Extract the worktree path from common git "already checked out" errors."""
+    if not stderr:
+        return None
+    patterns = (
+        r"checked out at '([^']+)'",
+        r"checked out at \"([^\"]+)\"",
+        r"used by worktree at '([^']+)'",
+        r"used by worktree at \"([^\"]+)\"",
+        r"worktree at '([^']+)'",
+        r"worktree at \"([^\"]+)\"",
+    )
+    for pat in patterns:
+        m = re.search(pat, stderr)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _current_branch(worktree_path: Path) -> str:
+    """Return the current branch name for a worktree path.
+
+    Returns "HEAD" when the worktree is detached.
+    """
+    proc = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd=worktree_path, check=False)
+    if proc.returncode != 0:
+        stderr = (proc.stderr or "").strip()
+        raise WorktreeError(
+            f"Unable to determine the current branch for worktree at {worktree_path}.",
+            details=stderr or None,
+            hint="The worktree may be corrupted. Try `git worktree prune` and retry.",
+        )
+    branch = (proc.stdout or "").strip()
+    if not branch:
+        raise WorktreeError(
+            f"Unable to determine the current branch for worktree at {worktree_path}.",
+            hint="The worktree may be corrupted. Try `git worktree prune` and retry.",
+        )
+    return branch
+
+def _list_worktree_paths(repo_root: Path) -> list[Path]:
+    proc = _run_git(["worktree", "list", "--porcelain"], cwd=repo_root, check=True)
+    paths: list[Path] = []
+    for line in (proc.stdout or "").splitlines():
+        line = line.strip()
+        if line.startswith("worktree "):
+            p = line[len("worktree ") :].strip()
+            if p:
+                paths.append(Path(p))
+    return paths
+
+
+def _git_stdout(args: Sequence[str], *, cwd: Path) -> str:
+    proc = _run_git(list(args), cwd=cwd, check=True)
+    return proc.stdout or ""
+
+
+def _run_git(args: Sequence[str], *, cwd: Path, check: bool) -> subprocess.CompletedProcess[str]:
+    cmd = ["git", *args]
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        raise WorktreeError(
+            "Unable to run git commands because `git` was not found on PATH.",
+            hint="Install Git and ensure the `git` command is available.",
+        )
+    except Exception as e:
+        raise WorktreeError(
+            f"Unable to run git command: {' '.join(cmd)}",
+            details=str(e),
+        )
+
+    if check and proc.returncode != 0:
+        stderr = (proc.stderr or "").strip()
+        stdout = (proc.stdout or "").strip()
+        details = "\n".join(part for part in [stderr, stdout] if part)
+        raise WorktreeError(
+            f"Git command failed (exit {proc.returncode}): {' '.join(cmd)}",
+            details=details or None,
+        )
+
+    return proc

{kiwi_code-0.0.43 → kiwi_code-0.0.431}/tests/test_cli_help.py

@@ -51,6 +51,9 @@ def test_kiwi_tui_help_exits_zero(isolated_home: Path) -> None:
     r = _run("kiwi_tui.main", "--help")
     assert r.returncode == 0, r.stderr
     assert "kiwi" in (r.stdout + r.stderr).lower()
+    combined = (r.stdout + r.stderr).lower()
+    assert "--worktree" in combined
+    assert "-w" in combined
 
 
 def test_kiwi_terminal_help_exits_zero(isolated_home: Path) -> None:

kiwi_code-0.0.431/tests/test_worktrees.py

@@ -0,0 +1,272 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from kiwi_tui.worktrees import WorktreeError, ensure_worktree
+
+
+def _git(cwd: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    env = os.environ.copy()
+    env.setdefault("GIT_AUTHOR_NAME", "Kiwi Test")
+    env.setdefault("GIT_AUTHOR_EMAIL", "kiwi-test@example.com")
+    env.setdefault("GIT_COMMITTER_NAME", "Kiwi Test")
+    env.setdefault("GIT_COMMITTER_EMAIL", "kiwi-test@example.com")
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_creates_under_dot_kiwi(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    r = _git(repo, "add", "README.md")
+    assert r.returncode == 0, r.stderr
+    r = _git(repo, "commit", "-m", "init")
+    assert r.returncode == 0, r.stderr
+
+    worktree_path, branch = ensure_worktree("feature-x", cwd=repo)
+    assert branch == "feature-x"
+
+    expected = (repo / ".kiwi" / "worktrees" / "feature-x").resolve()
+    assert worktree_path.resolve() == expected
+    assert worktree_path.exists()
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert head == "feature-x"
+
+    # Should be registered with git.
+    wt_list = subprocess.check_output(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=str(repo),
+        text=True,
+    )
+    assert str(expected) in wt_list
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_reuses_existing(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    p1, _b1 = ensure_worktree("reuse-me", cwd=repo)
+    p2, _b2 = ensure_worktree("reuse-me", cwd=repo)
+    assert p1.resolve() == p2.resolve()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_generates_name(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    monkeypatch.setattr("kiwi_tui.worktrees.generate_worktree_name", lambda: "bright-running-fox")
+    worktree_path, branch = ensure_worktree(None, cwd=repo)
+
+    assert branch == "bright-running-fox"
+    expected = (repo / ".kiwi" / "worktrees" / "bright-running-fox").resolve()
+    assert worktree_path.resolve() == expected
+
+
+def test_ensure_worktree_requires_git_repo(tmp_path: Path) -> None:
+    # Not a git repo.
+    with pytest.raises(WorktreeError) as exc:
+        ensure_worktree("x", cwd=tmp_path)
+
+    # Message should be user-facing.
+    assert "git" in str(exc.value).lower() or "repository" in str(exc.value).lower()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_uses_remote_branch_when_local_missing(tmp_path: Path) -> None:
+    """If origin/<branch> exists but no local branch, create a tracking branch."""
+    remote = tmp_path / "remote.git"
+    remote.mkdir()
+    r = _git(remote, "init", "--bare")
+    assert r.returncode == 0, r.stderr
+
+    seed = tmp_path / "seed"
+    seed.mkdir()
+    r = _git(seed, "init", "-b", "main")
+    assert r.returncode == 0, r.stderr
+    (seed / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(seed, "add", "README.md").returncode == 0
+    assert _git(seed, "commit", "-m", "init").returncode == 0
+    assert _git(seed, "remote", "add", "origin", str(remote)).returncode == 0
+    assert _git(seed, "push", "-u", "origin", "main").returncode == 0
+    # Ensure the bare remote's HEAD points at main so clones have a valid HEAD.
+    assert _git(remote, "symbolic-ref", "HEAD", "refs/heads/main").returncode == 0
+
+
+    # Create and push a feature branch, then leave it as remote-only in the clone.
+    assert _git(seed, "checkout", "-b", "feature-remote").returncode == 0
+    (seed / "feature.txt").write_text("feature\n", encoding="utf-8")
+    assert _git(seed, "add", "feature.txt").returncode == 0
+    assert _git(seed, "commit", "-m", "feature").returncode == 0
+    assert _git(seed, "push", "-u", "origin", "feature-remote").returncode == 0
+
+    repo = tmp_path / "repo"
+    clone = subprocess.run(
+        ["git", "clone", str(remote), str(repo)],
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert clone.returncode == 0, clone.stderr
+
+    # Sanity: local branch should not exist yet.
+    assert _git(repo, "show-ref", "--verify", "refs/heads/feature-remote").returncode != 0
+    assert _git(repo, "show-ref", "--verify", "refs/remotes/origin/feature-remote").returncode == 0
+
+    worktree_path, branch = ensure_worktree("feature-remote", cwd=repo)
+    assert branch == "feature-remote"
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert head == "feature-remote"
+
+    upstream = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cwd=str(worktree_path),
+        text=True,
+    ).strip()
+    assert upstream == "origin/feature-remote"
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_recovers_from_missing_dir(tmp_path: Path) -> None:
+    """If a worktree is registered but its directory was deleted, recover via prune."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    worktree_path, _branch = ensure_worktree("stale-branch", cwd=repo)
+    assert worktree_path.exists()
+
+    # Simulate user manually deleting the directory (leaving git's worktree metadata stale).
+    shutil.rmtree(worktree_path)
+    assert not worktree_path.exists()
+
+    worktree_path2, _branch2 = ensure_worktree("stale-branch", cwd=repo)
+    assert worktree_path2.resolve() == worktree_path.resolve()
+    assert worktree_path2.exists()
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_errors_if_existing_folder_on_wrong_branch(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    # Create both branches without checking them out in the main worktree.
+    assert _git(repo, "branch", "branch-a").returncode == 0
+    assert _git(repo, "branch", "branch-b").returncode == 0
+
+    # Create the worktree for branch-a.
+    worktree_path, _branch = ensure_worktree("branch-a", cwd=repo)
+    assert worktree_path.exists()
+
+    # Switch the worktree folder to branch-b.
+    switched = subprocess.run(
+        ["git", "switch", "branch-b"],
+        cwd=str(worktree_path),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert switched.returncode == 0, switched.stderr
+
+    with pytest.raises(WorktreeError):
+        ensure_worktree("branch-a", cwd=repo)
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git is required for worktree tests")
+def test_ensure_worktree_prunes_stale_checked_out_branch(tmp_path: Path) -> None:
+    """If git thinks a branch is checked out in a deleted Kiwi worktree, prune + retry."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    r = _git(repo, "init")
+    assert r.returncode == 0, r.stderr
+
+    (repo / "README.md").write_text("hello\n", encoding="utf-8")
+    assert _git(repo, "add", "README.md").returncode == 0
+    assert _git(repo, "commit", "-m", "init").returncode == 0
+
+    # Create both branches without checking them out in the main worktree.
+    assert _git(repo, "branch", "branch-a").returncode == 0
+    assert _git(repo, "branch", "branch-b").returncode == 0
+
+    # Create the worktree at .kiwi/worktrees/branch-a and then switch it to branch-b.
+    worktree_a, _ = ensure_worktree("branch-a", cwd=repo)
+    switched = subprocess.run(
+        ["git", "switch", "branch-b"],
+        cwd=str(worktree_a),
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert switched.returncode == 0, switched.stderr
+
+    # Delete the worktree directory without unregistering it (stale git metadata).
+    shutil.rmtree(worktree_a)
+    assert not worktree_a.exists()
+
+    worktree_b, branch = ensure_worktree("branch-b", cwd=repo)
+    assert branch == "branch-b"
+    assert worktree_b.exists()
+
+    head = subprocess.check_output(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=str(worktree_b),
+        text=True,
+    ).strip()
+    assert head == "branch-b"

{kiwi_code-0.0.43 → kiwi_code-0.0.431}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.43"
+version = "0.0.431"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },