git-worktrees 0.2.1__tar.gz → 0.2.3__tar.gz

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/.github/workflows/publish.yml

@@ -5,6 +5,7 @@ name: Publish
 # so a rename means re-registering the publisher on PyPI first.
 #
 #   build -> publish-test -> publish -> release
+#                                     \-> verify
 #
 # Nothing here creates a tag. A release is a version bump merged into main and
 # then tagged by hand, so the irreversible step is the last one and everything
@@ -91,6 +92,11 @@ jobs:
       - name: Install dependencies
         run: uv sync --all-extras --locked
 
+      # Neither shell is on the image, and the shim tests fail rather than
+      # skip under CI, so this job needs them exactly as tests.yml does.
+      - name: Install fish and zsh
+        run: sudo apt-get update && sudo apt-get install -y fish zsh
+
       # The tag is the last chance to catch a regression, and it costs 20s.
       - name: Run tests
         run: uv run --no-sync pytest tests -q
@@ -166,16 +172,34 @@ jobs:
           name: dist
           path: dist/
 
-      - name: Install the release tools
-        uses: releasetools/cli@v0
-
       - name: Publish
         run: uv publish --trusted-publishing always
 
-      # An index serves what it has just accepted only after a delay, so the
-      # script retries the resolution rather than polling a different endpoint
-      # first: the JSON API answered for 0.2.0 while the simple index uv reads
-      # had not caught up, and the run went red on a publish that had worked.
+  # Uploaded and installable are two claims with two timings, so they are two
+  # jobs. An index serves what it has accepted only after a delay of its own
+  # choosing: 0.2.1 took longer than the script waited, and a release that had
+  # published correctly went red and had to be re-run by hand. This job holds
+  # the second claim, `release` needs only the first, and a red `verify` says
+  # PyPI is slow rather than that the version is not out.
+  verify:
+    name: Verify it installs from PyPI
+    runs-on: ubuntu-latest
+    needs: publish
+    permissions:
+      contents: read
+    steps:
+      # The script reads the name and version from pyproject.toml through
+      # `uv version`, and installs from the index rather than from the
+      # artifact, so there is nothing to download here.
+      - name: Checkout code
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@ae62891fec2bb8e7d6c99fc78c9fec3a63790f8d # v10.0.0
+        with:
+          python-version: "3.14"
+          enable-cache: true
+
       - name: Verify it installs from PyPI
         run: scripts/verify-publish.bash --prod
 

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/.github/workflows/tests.yml

@@ -67,11 +67,17 @@ jobs:
         # resolving something the lock file never described.
         run: uv sync --all-extras --locked
 
+      # Neither shell is on the image. Without them the nine assertions that
+      # drive a real fish or zsh call pytest.skip, which is invisible in
+      # `pytest -q`, so the run goes green without either shim ever running.
+      - name: Install fish and zsh
+        run: sudo apt-get update && sudo apt-get install -y fish zsh
+
       # The suite drives real git: it builds repositories, adds worktrees and
       # removes them. Recording the version makes a failure that is git's
       # rather than ours readable from the log alone.
       - name: Record the git version
-        run: git --version
+        run: git --version && fish --version && zsh --version
 
       - name: Run tests
         run: uv run --no-sync pytest tests -q

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/.gitignore

@@ -5,3 +5,6 @@ __pycache__/
 .mypy_cache/
 .venv/
 dist/
+
+# Written by hatch_build.py during a build.
+src/worktrees/_version.py

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/AGENTS.md

@@ -238,10 +238,30 @@ tested on what it returns rather than on its exit code. `upstream_of` takes
 `ok=(0, 1, 128)`, so a typo in one of its flags exits 128, reads as "no
 upstream", and turns every branch into `unknown` with nothing failing.
 
+The two calls that reach the network, `fetch` and `remote set-head --auto`,
+take `ok=(0, 128)` for the same reason in reverse: a remote that cannot be
+reached is an answer rather than a failure. The caller reads the result, says
+so on stderr, and carries on with the refs already here, which is where
+`--no-fetch` sends it on request. It also stops asking: a failed fetch means
+the head-branch ladder is told it is offline, rather than spending a second
+round trip proving it.
+
+One `git status --porcelain --ignored=traditional` answers both questions a
+worktree is asked. It is a strict superset of plain `--porcelain`, so `dirty`
+is "a line that does not start with `!! `" and `ignored` is the rest. Asking
+both ways was 18 of an assessment's 35 calls over nine worktrees.
+
 `guard()` runs on the resolved argv inside the wrapper, not at declaration, so
 no call site can assemble its way past it. `reset --hard`, a forced `checkout`
-or `switch`, `clean -f`, a bare `push --force`, `worktree remove --force` and
-`branch -D` are refused absolutely. There is no flag, and `--yes` least of all.
+or `switch`, `clean -f`, a bare `push --force`, `worktree remove --force`,
+`branch -D` and an `update-ref` delete that names no full sha are refused
+absolutely. There is no flag, and `--yes` least of all.
+
+Those seven are `RULES`, a tuple, each row carrying the name `--explain`
+prints, the clause the refusal ends with, and the test. The footer `--explain`
+prints is built from it. A rule written in one place and described in another
+is a rule that goes quiet: the hand-written footer fell a rule behind the
+moment `update-ref` was added, and nothing failed.
 
 `verdicts.py` declares no mutating command. A read-only command may not call
 one: a test reads the verbose log and asserts it.

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/CHANGELOG.md

@@ -12,6 +12,39 @@ not in here, whatever it cost to build.
 A release closes with a `### Choices` section when a decision in it is worth
 the reader's time: what was chosen, and what the alternative failed to do.
 
+## 0.2.3 - 2026-09-11
+
+An unreachable remote is an answer rather than a failure. Every command that
+touches the network used to exit 1 with git's own message, so the warnings
+written for the offline case never reached anybody. A failed fetch now says
+the refs are the ones already here, and the assessment carries on.
+
+Refusing to prompt exits 3 everywhere. `gwp` used to exit 2 when stdin was
+not a terminal, which is argparse's code for a usage error, so a script could
+not tell a refusal from a typo.
+
+Removing a worktree names the stash entries made on its branch. A stash
+outlives the branch while its subject goes on naming it, which is how it
+becomes unfindable.
+
+`gwr` asks the forge once, about the branch it is removing, instead of about
+every worktree: three round trips became one in a three-worktree repository.
+`--no-forge` turns it off there, as it already did for `gws` and `gwp`.
+
+`--explain` lists all seven refusals the guard enforces. The footer was
+written by hand and had been a rule behind since `update-ref` was added.
+
+An invocation costs about 15 ms less, and an assessment makes half as many
+`git status` calls.
+
+### Choices
+
+The version is written into the wheel at build time rather than read back
+through `importlib.metadata`, which cost 10 ms of a 67 ms invocation for a
+string two commands print. Deriving it from the tag with `hatch-vcs` was the
+alternative, and it inverts which of the tag and `pyproject.toml` has to
+agree with the other.
+
 ## 0.2.1 - 2026-09-11
 
 `--version` is gone from every command. `gw version`, or `gw v`, prints the

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-worktrees
-Version: 0.2.1
+Version: 0.2.3
 Summary: Git worktree commands that refuse to lose work.
 Project-URL: Bug reports, https://github.com/MihaiBojin/worktrees/issues/new
 Project-URL: Source, https://github.com/MihaiBojin/worktrees
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.11
 Provides-Extra: dev
+Requires-Dist: hatchling==1.28.0; extra == 'dev'
 Requires-Dist: pre-commit==4.6.1; extra == 'dev'
 Requires-Dist: pytest==9.1.1; extra == 'dev'
 Description-Content-Type: text/markdown
@@ -222,6 +223,12 @@ function returns that set for both. What goes and what puts it back is printed
 before anything does, and neither `--quiet` nor `--yes` silences it. The sha in
 the restore line is full length, because that line is meant to be pasted.
 
+A stash made on a branch that is about to go is named too. `refs/stash` is
+per-repository and pins its own commits, so the entry survives the branch and
+`git stash branch <new> stash@{0}` still recovers it. What does not survive is
+the branch name in its subject, so the line says which entry is about to start
+pointing at nothing.
+
 The checkout goes through plain `git worktree remove`, so every refusal git
 makes still applies. The branch goes through `git update-ref -d`, naming the
 sha the verdict was formed against: a branch somebody committed to in between
@@ -240,7 +247,8 @@ squash-merged  /home/you/git/.worktrees/squash-merged/repo
 not a terminal, so nothing can answer for the 1 above; pass --yes to remove them
 ```
 
-That exits 2 and touches nothing. `gwp --yes --json` is what an agent runs.
+That exits 3 and touches nothing, the code every refusal uses. `gwp --yes --json`
+is what an agent runs.
 
 With nothing to remove it prints the table `gws` prints, rather than the name
 of the command that would have printed it. The reason each worktree stayed is
@@ -422,13 +430,17 @@ print one thing each and have nothing to be quiet about, takes `--json`, `-q`,
 | --- | --- |
 | `gws` | `--branch NAME`, `--no-fetch`, `--delete-ignored`, `--no-forge` |
 | `gwp` | those four, and `-y` |
-| `gwr` | `-f`, `--delete-ignored`, `--no-fetch`, `-y` |
+| `gwr` | `-f`, `--delete-ignored`, `--no-fetch`, `--no-forge`, `-y` |
 | `gwa`, `gwnb`, `gwrot` | `--no-fetch` |
 | `gwl` | `-l` |
 | `gwm`, `gwh` | none |
 
 `gw <command> --help` prints one command's own list.
 
+A remote that cannot be reached is not fatal anywhere. The fetch fails, the
+command says so on stderr, and it answers from the refs already here, which is
+where `--no-fetch` sends it on request.
+
 Data goes to stdout and diagnostics to stderr, the prompt included, so `--json`
 is parseable in every mode. Colour is decided per stream and only for a
 terminal, so a redirect, a pipe, a non-empty `NO_COLOR` or `TERM=dumb` give the
@@ -460,12 +472,14 @@ and whatever a caller asks for:
 ```
 reset --hard      a forced checkout or switch      clean -f
 push --force      worktree remove --force          branch -D
+an update-ref delete that names no full sha
 ```
 
 The check runs on the argument list as it is about to be handed to git, so no
 code path can assemble its way past one. `gws --explain` prints every git
 command the program can issue, marking the ones that take the repository's
-shared refs and therefore run serially.
+shared refs and therefore run serially, and ends with that list of seven,
+generated from the rules rather than written out beside them.
 
 `--force-with-lease` is not `--force` and is allowed, and so is
 `update-ref -d <ref> <sha>`, which is how a branch is deleted here: against the

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/README.md

@@ -197,6 +197,12 @@ function returns that set for both. What goes and what puts it back is printed
 before anything does, and neither `--quiet` nor `--yes` silences it. The sha in
 the restore line is full length, because that line is meant to be pasted.
 
+A stash made on a branch that is about to go is named too. `refs/stash` is
+per-repository and pins its own commits, so the entry survives the branch and
+`git stash branch <new> stash@{0}` still recovers it. What does not survive is
+the branch name in its subject, so the line says which entry is about to start
+pointing at nothing.
+
 The checkout goes through plain `git worktree remove`, so every refusal git
 makes still applies. The branch goes through `git update-ref -d`, naming the
 sha the verdict was formed against: a branch somebody committed to in between
@@ -215,7 +221,8 @@ squash-merged  /home/you/git/.worktrees/squash-merged/repo
 not a terminal, so nothing can answer for the 1 above; pass --yes to remove them
 ```
 
-That exits 2 and touches nothing. `gwp --yes --json` is what an agent runs.
+That exits 3 and touches nothing, the code every refusal uses. `gwp --yes --json`
+is what an agent runs.
 
 With nothing to remove it prints the table `gws` prints, rather than the name
 of the command that would have printed it. The reason each worktree stayed is
@@ -397,13 +404,17 @@ print one thing each and have nothing to be quiet about, takes `--json`, `-q`,
 | --- | --- |
 | `gws` | `--branch NAME`, `--no-fetch`, `--delete-ignored`, `--no-forge` |
 | `gwp` | those four, and `-y` |
-| `gwr` | `-f`, `--delete-ignored`, `--no-fetch`, `-y` |
+| `gwr` | `-f`, `--delete-ignored`, `--no-fetch`, `--no-forge`, `-y` |
 | `gwa`, `gwnb`, `gwrot` | `--no-fetch` |
 | `gwl` | `-l` |
 | `gwm`, `gwh` | none |
 
 `gw <command> --help` prints one command's own list.
 
+A remote that cannot be reached is not fatal anywhere. The fetch fails, the
+command says so on stderr, and it answers from the refs already here, which is
+where `--no-fetch` sends it on request.
+
 Data goes to stdout and diagnostics to stderr, the prompt included, so `--json`
 is parseable in every mode. Colour is decided per stream and only for a
 terminal, so a redirect, a pipe, a non-empty `NO_COLOR` or `TERM=dumb` give the
@@ -435,12 +446,14 @@ and whatever a caller asks for:
 ```
 reset --hard      a forced checkout or switch      clean -f
 push --force      worktree remove --force          branch -D
+an update-ref delete that names no full sha
 ```
 
 The check runs on the argument list as it is about to be handed to git, so no
 code path can assemble its way past one. `gws --explain` prints every git
 command the program can issue, marking the ones that take the repository's
-shared refs and therefore run serially.
+shared refs and therefore run serially, and ends with that list of seven,
+generated from the rules rather than written out beside them.
 
 `--force-with-lease` is not `--force` and is allowed, and so is
 `update-ref -d <ref> <sha>`, which is how a branch is deleted here: against the

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/completions/gwr.fish

@@ -7,6 +7,7 @@ complete -c gwr -a '(command gwr --complete)'
 complete -c gwr -s f -l force -d 'remove it even when unfinished'
 complete -c gwr -l delete-ignored -d 'also delete its gitignored files'
 complete -c gwr -l no-fetch -d 'use the refs already here'
+complete -c gwr -l no-forge -d 'decide from git alone; never ask the forge'
 complete -c gwr -s y -l yes -d 'do not ask'
 
 complete -c gwr -l json -d 'the result as data'

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/docs/DEVELOPMENT.md

@@ -182,6 +182,7 @@ Pushing the tag starts `publish.yml`:
 
 ```
 build ──> publish-test ──> publish ──> release
+                                   └─> verify
 ```
 
 `build` runs three guards before it does anything, cheapest first. The tag has
@@ -196,6 +197,12 @@ replaced, so a failed rehearsal stops the run while there is still nothing to
 pin against. The merge happens first and the irreversible step is last, so
 everything recoverable is already done by the time anything is published.
 
+`release` needs the upload and nothing else. `verify` installs the version
+from PyPI and runs what it installed, on its own, because an index serves what
+it has accepted after a delay it does not bound: 0.2.1 took longer than the
+script waited and a correct release went red. A red `verify` says PyPI is
+slow, not that the version is missing. It gives up after about 32 minutes.
+
 `workflow_dispatch` against a tag ref re-runs a release whose publish failed.
 
 No API token is stored anywhere. Both uploads use PyPI Trusted Publishing over

git_worktrees-0.2.3/hatch_build.py

@@ -0,0 +1,49 @@
+"""Write the version `pyproject.toml` declares into the package it builds.
+
+Reading it back through `importlib.metadata` at import instead costs 10 ms of
+a 67 ms invocation, on every command, for a string two of them print. A
+constant in the wheel costs nothing, and `pyproject.toml` stays the one place
+the version is written.
+
+Not `hatch-vcs`: deriving the version from a tag inverts which of the two has
+to agree with the other, and `publish.yml` refuses a tag whose commit carries
+a different version.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+GENERATED = Path("src") / "worktrees" / "_version.py"
+
+
+def rendered(version: str) -> str:
+    """The file's whole contents."""
+    return (
+        '"""Written at build time. See hatch_build.py."""\n'
+        f'\n__version__ = "{version}"\n'
+    )
+
+
+def generate(root: Path, version: str, build_data: dict[str, Any]) -> Path:
+    """Write the file, and tell the builder to ship it.
+
+    Both halves, because either alone is silent. `.gitignore` keeps the
+    generated file out of the repository and hatchling reads `.gitignore`, so
+    without the artifacts entry the wheel ships without it and every install
+    falls back to the metadata lookup with nothing to say so.
+    """
+    target = root / GENERATED
+    target.write_text(rendered(version))
+    build_data.setdefault("artifacts", []).append(f"/{GENERATED.as_posix()}")
+    return target
+
+
+class VersionHook(BuildHookInterface):
+    PLUGIN_NAME = "custom"
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        generate(Path(self.root), self.metadata.version, build_data)

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/pyproject.toml

@@ -9,10 +9,10 @@ authors = [
 ]
 # Static, and the single source of truth for the version. Bump it in a pull
 # request and run `uv lock`; the release tag only has to agree with it.
-version = "0.2.1"
+version = "0.2.3"
 # The standard library answers every question this asks. A dependency here
-# would be paid on every invocation, and the whole reason this is Python is
-# that an invocation costs ~25 ms.
+# would be paid on every invocation, and an invocation is 67 ms of which 25 ms
+# is the interpreter starting.
 dependencies = []
 requires-python = ">=3.11"
 classifiers = [
@@ -30,6 +30,9 @@ classifiers = [
 [project.optional-dependencies]
 dev = [
     # keep-sorted start
+    # The build backend, because tests/test_version.py drives the build hook
+    # that writes the version into the wheel.
+    "hatchling==1.28.0",
     "pre-commit==4.6.1",
     "pytest==9.1.1",
     # keep-sorted end
@@ -70,6 +73,11 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/worktrees"]
 
+# Writes src/worktrees/_version.py from the version above, so an invocation
+# reads a constant rather than asking importlib.metadata. See hatch_build.py.
+[tool.hatch.build.targets.wheel.hooks.custom]
+path = "hatch_build.py"
+
 [tool.ruff]
 line-length = 88
 target-version = "py311"
@@ -102,5 +110,10 @@ warn_unused_ignores = true
 # keep-sorted end
 files = ["src", "tests"]
 
+[[tool.mypy.overrides]]
+# Generated at build time and absent from a checkout.
+module = "worktrees._version"
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/scripts/verify-publish.bash

@@ -39,9 +39,10 @@ trap 'rm -rf "$TMP"' EXIT
 # still could not find it. So the wait is this resolution retried rather than a different
 # endpoint polled, because this is the condition a green publish is claiming.
 #
-# Six attempts backing off from 15s is about 7.75 minutes, and it stops the moment the
-# version resolves.
-readonly ATTEMPTS=6
+# Eight attempts backing off from 15s is about 32 minutes, and it stops the moment the
+# version resolves. Nothing waits on this job, so the budget is how long PyPI is given
+# before somebody is told it is slow.
+readonly ATTEMPTS=8
 readonly BASE=15
 
 # The version the installed command reports, compared against the one asked

git_worktrees-0.2.3/src/worktrees/__init__.py

@@ -0,0 +1,15 @@
+"""Git worktree commands that refuse to lose work."""
+
+try:
+    # Written into the wheel by hatch_build.py, from the version
+    # pyproject.toml declares. Asking importlib.metadata for it instead costs
+    # 10 ms of a 67 ms invocation, on every command, for a string two of them
+    # print.
+    from ._version import __version__
+except ImportError:  # a checkout, or an editable install of one
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        __version__ = version("git-worktrees")
+    except PackageNotFoundError:  # a source tree nothing has installed
+        __version__ = "0+unknown"

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/src/worktrees/cli.py

@@ -14,7 +14,7 @@ from . import __version__, new_branch, pick, prune, render, verdicts
 from . import repo as R
 from . import rotate as rotate_mod
 from . import worktree as wt_mod
-from .git import GitError, Refused, commands, options
+from .git import RULES, GitError, Refused, commands, options
 from .render import BLUE, BOLD, DIM, GREEN, RED, YELLOW, Cell, Row, table
 
 
@@ -79,11 +79,20 @@ def _explain() -> int:
         )
     print(table(rows))
     print()
+    # Generated from the guard itself. The footer used to be a sentence
+    # written by hand in this file, and it fell a rule behind the moment one
+    # was added.
+    import textwrap
+
+    named = [rule.named for rule in RULES]
+    listed = ", ".join(named[:-1]) + " and " + named[-1]
     print(
-        "! takes the repository's shared refs and runs serially. The guard "
-        "refuses\n  reset --hard, a forced checkout or switch, clean -f, push "
-        "--force,\n  worktree remove --force and branch -D outright, whatever "
-        "flags are passed."
+        textwrap.fill(
+            "! takes the repository's shared refs and runs serially. The guard "
+            f"refuses these outright, whatever flags are passed: {listed}.",
+            width=76,
+            subsequent_indent="  ",
+        )
     )
     return 0
 
@@ -130,7 +139,8 @@ class _Stop(Exception):
 def _assess(
     args: argparse.Namespace,
     judge: Callable[..., list[verdicts.Verdict]] | None = None,
-) -> tuple[list[verdicts.Verdict], list[R.Worktree], str]:
+    ask_forge: bool | None = None,
+) -> tuple[list[verdicts.Verdict], list[R.Worktree], str, str]:
     """Fetch, resolve the head branch, and judge every worktree.
 
     The one path every command takes, so `prune` can only ever act on what
@@ -138,13 +148,21 @@ def _assess(
     to be judged like any other, having stepped out of it first.
     """
     remote = R.remote()
-    if not args.no_fetch:
-        if remote:
-            R.fetch(remote)
+    online = not args.no_fetch
+    if online:
+        # An unreachable remote is not a reason to refuse to answer. It lands
+        # where --no-fetch already goes, and says so, and the head-branch
+        # ladder is told not to spend a second round trip on the same remote.
+        if remote and not R.fetch(remote):
+            online = False
+            if not args.quiet:
+                _err(
+                    f"{remote} could not be fetched; judging from the refs already here"
+                )
     elif not args.quiet:
         _err("using the refs already here; they may be stale (--no-fetch)")
 
-    head, warning = R.head_ref(remote, online=not args.no_fetch)
+    head, warning = R.head_ref(remote, online=online)
     if warning and not args.quiet:
         _err(warning)
     if not head:
@@ -160,7 +178,8 @@ def _assess(
     # round trip, and a branch merged as part of a stack is the one case
     # content cannot answer: its changes reach the head branch across several
     # squashes, so a stale intermediate and real work look alike to a diff.
-    ask_forge = not getattr(args, "no_forge", False)
+    if ask_forge is None:
+        ask_forge = not getattr(args, "no_forge", False)
     rows = (
         judge(only, head, head_branch, ignored, ask_forge=ask_forge)
         if judge
@@ -168,7 +187,7 @@ def _assess(
             records, only, head, head_branch, ignored, ask_forge=ask_forge
         )
     )
-    return rows, verdicts.stale(records), head
+    return rows, verdicts.stale(records), head, head_branch
 
 
 # --------------------------------------------------------------------------
@@ -182,7 +201,7 @@ def run_status(args: argparse.Namespace) -> int:
     if args.explain:
         return _explain()
 
-    rows, stale, head = _assess(args)
+    rows, stale, head, _ = _assess(args)
     go = prune.removable(rows)
     unknown = [v for v in rows if v.verdict == verdicts.UNKNOWN]
 
@@ -253,7 +272,7 @@ def run_prune(args: argparse.Namespace) -> int:
     # neither command may propose removing one.
     prune.worktree_prune()
 
-    rows, _, _ = _assess(args)
+    rows, _, _, _ = _assess(args)
     go = prune.removable(rows)
     unknown = [v for v in rows if v.verdict == verdicts.UNKNOWN]
 
@@ -280,14 +299,11 @@ def run_prune(args: argparse.Namespace) -> int:
     # --quiet and --yes do not silence it.
     prune.plan(go, _err)
 
-    if not args.yes:
-        try:
-            if not prune.confirm(len(go)):
-                _err("nothing removed")
-                return 0
-        except Refused as exc:
-            _err(render.err(str(exc), RED))
-            return 2
+    # A Refused from here goes to _dispatch, which exits 3 for every refusal.
+    # No terminal is one condition, so it is one code wherever it is met.
+    if not args.yes and not prune.confirm(len(go)):
+        _err("nothing removed")
+        return 0
 
     failed = prune.sweep(go, _err)
     removed = [v.label for v in go]
@@ -485,6 +501,11 @@ def _add_remove_flags(p: argparse.ArgumentParser) -> None:
         help="also delete its gitignored files; nothing restores them",
     )
     p.add_argument("--no-fetch", action="store_true", help="use the refs already here")
+    p.add_argument(
+        "--no-forge",
+        action="store_true",
+        help="decide from git alone; never ask the forge",
+    )
     p.add_argument("-y", "--yes", action="store_true", help="do not ask")
     # Its own, not gwl's: assess skips the main checkout, so gwr can never act
     # on it and offering it would complete to "no worktree matches".
@@ -637,7 +658,10 @@ def run_remove(args: argparse.Namespace) -> int:
                 print(f"{w.label}\t{w.path}")
         return 0
 
-    rows, _, _ = _assess(args, judge=wt_mod.removable)
+    # The picker shows a path and a branch and no verdict, so nothing before
+    # the answer needs the forge. Scanning without it turns one round trip per
+    # worktree into at most one for the whole command.
+    rows, _, head, head_branch = _assess(args, judge=wt_mod.removable, ask_forge=False)
     found = pick.matches(
         args.query, [R.Worktree(v.path, "", v.branch, frozenset()) for v in rows]
     )
@@ -660,6 +684,15 @@ def run_remove(args: argparse.Namespace) -> int:
         return 0
     chosen = by_path[picked.path]
 
+    # Now that there is one branch, the forge is worth a question: it is the
+    # only thing that settles a branch merged as part of a stack.
+    if chosen.verdict != prune.REMOVE and not args.no_forge:
+        judged = wt_mod.removable(
+            chosen.branch, head, head_branch, args.delete_ignored, ask_forge=True
+        )
+        if judged:
+            chosen = judged[0]
+
     if chosen.verdict != prune.REMOVE and not args.force:
         # A finished branch held back by ignored files is not an unfinished
         # branch. Saying so would contradict the reason printed beside it,
@@ -675,14 +708,9 @@ def run_remove(args: argparse.Namespace) -> int:
         return 1
 
     prune.plan([chosen], _err)
-    if not args.yes:
-        try:
-            if not prune.confirm(1):
-                _err("nothing removed")
-                return 0
-        except Refused as exc:
-            _err(render.err(str(exc), RED))
-            return 2
+    if not args.yes and not prune.confirm(1):
+        _err("nothing removed")
+        return 0
 
     keep_branch = chosen.verdict != prune.REMOVE
     # --force keeps the branch: the worktree was in the way, the work was not.

{git_worktrees-0.2.1 → git_worktrees-0.2.3}/src/worktrees/forge.py

@@ -15,7 +15,6 @@ from __future__ import annotations
 
 import json
 import os
-import shutil
 import subprocess
 from dataclasses import dataclass
 
@@ -32,7 +31,14 @@ class Request:
 
 
 def available() -> str:
-    """The forge CLI on PATH, or empty when there is none."""
+    """The forge CLI on PATH, or empty when there is none.
+
+    shutil costs 4.7 ms to import and one call needs it, so it is imported
+    here rather than at the top: every command that never asks the forge pays
+    nothing for the question.
+    """
+    import shutil
+
     for tool in ("gh", "glab"):
         if shutil.which(tool):
             return tool