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

{git_worktrees-0.2.0 → 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
@@ -74,19 +75,28 @@ jobs:
       # release that should go ahead. The API needs no local history.
       - name: Check the commit is on main
         env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
+          # GH_REPO carries the value the runner publishes as GITHUB_REPOSITORY: gh looks for
+          # GH_REPO and never at GITHUB_REPOSITORY. GITHUB_TOKEN is not a default variable at
+          # all, so the token has to be handed over rather than renamed.
+          GH_TOKEN: ${{ github.token }} # no runner default
+          GH_REPO: ${{ github.repository }} # = $GITHUB_REPOSITORY; gh reads GH_REPO
         run: rt github::assert_on_branch main
 
       - name: Wait for the tests on this commit
         env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-        run: rt github::await_workflow "$GITHUB_SHA" tests.yml
+          GH_TOKEN: ${{ github.token }} # no runner default
+          GH_REPO: ${{ github.repository }} # = $GITHUB_REPOSITORY; gh reads GH_REPO
+          SHA: ${{ github.sha }} # = $GITHUB_SHA
+        run: rt github::await_workflow "$SHA" tests.yml
 
       - 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
@@ -162,18 +172,33 @@ 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, and a fixed
-      # sleep either wastes time or fails a publish that worked. This backs off
-      # across about 7.75 minutes and stops as soon as the version is there.
-      - name: Wait for the PyPI index to catch up
-        run: |
-          rt net::await_url "https://pypi.org/pypi/$(uv version | tr ' ' '/')/json"
+  # 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.0 → 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.0 → 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.0 → git_worktrees-0.2.3}/AGENTS.md

@@ -156,6 +156,11 @@ shorthands and whether the command changes the caller's directory. `gws`,
 so, and `gwh` prints the table rather than a second list that can disagree
 with it.
 
+`version` is the one row that installs no console script, and `gwh` prints a
+`—` in its first column to say so. A tool's version is asked through the
+tool's name, so `gw version` and `gw v` are the two spellings and no parser
+carries a `--version` flag.
+
 `_canonical()` raises at import when two rows answer to one name. A dict
 comprehension would keep the last one and leave a command reachable under a
 name that runs a different one.
@@ -233,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.0 → git_worktrees-0.2.3}/CHANGELOG.md

@@ -12,6 +12,62 @@ 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
+version this package installs; `gws --version` and the rest now fail as an
+unrecognised argument, so a script reading the version back has one line to
+change.
+
+A name `gw` does not carry names the closest one that exists, instead of
+printing a usage line and all twenty-two commands under an argparse error:
+
+    $ gw verison
+    gw: there is no command 'verison'
+    the closest is: gw version
+    gw help lists every command
+
+### Choices
+
+`version` installs no binary of its own, and `gwh` prints a `—` in its
+column to say so. A tenth console script, for a question asked once, would
+be a name nobody types. Keeping `--version` beside it was the alternative:
+two spellings of one answer, on every command, each to be completed,
+documented and tested.
+
 ## 0.2.0 - 2026-09-11
 
 A squash-merged branch goes with its checkout, every removal names the

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-worktrees
-Version: 0.2.0
+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
@@ -404,6 +412,7 @@ gwr [QUERY]      gw remove (rm)           remove one whose branch is finished
 gwnb NAME        gw new-branch (nb, new)  branch off the head branch (alpha)
 gwrot            gw rotate (rot)          the next branch in a series (alpha)
 gwh              gw help (h)              every command and alias, this list
+—                gw version (v)           the version this package installs
 ```
 
 `gw help`, `gw h` and `gw` with no subcommand print the same thing. One table
@@ -412,21 +421,26 @@ cannot disagree, and it raises at import if two commands ever claim one name.
 
 ## Flags
 
-Every command takes `--version`. All but `gwh`, which prints a table and has
-nothing to be quiet about, also take `--json`, `-q`, `-v` and `--explain`.
-Beyond those:
+`gw version`, or `gw v`, prints the version. No command takes a `--version`
+flag. Every command but that one and `gwh`, which
+print one thing each and have nothing to be quiet about, takes `--json`, `-q`,
+`-v` and `--explain`. Beyond those:
 
 | | |
 | --- | --- |
 | `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
@@ -458,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.0 → 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
@@ -379,6 +386,7 @@ gwr [QUERY]      gw remove (rm)           remove one whose branch is finished
 gwnb NAME        gw new-branch (nb, new)  branch off the head branch (alpha)
 gwrot            gw rotate (rot)          the next branch in a series (alpha)
 gwh              gw help (h)              every command and alias, this list
+—                gw version (v)           the version this package installs
 ```
 
 `gw help`, `gw h` and `gw` with no subcommand print the same thing. One table
@@ -387,21 +395,26 @@ cannot disagree, and it raises at import if two commands ever claim one name.
 
 ## Flags
 
-Every command takes `--version`. All but `gwh`, which prints a table and has
-nothing to be quiet about, also take `--json`, `-q`, `-v` and `--explain`.
-Beyond those:
+`gw version`, or `gw v`, prints the version. No command takes a `--version`
+flag. Every command but that one and `gwh`, which
+print one thing each and have nothing to be quiet about, takes `--json`, `-q`,
+`-v` and `--explain`. Beyond those:
 
 | | |
 | --- | --- |
 | `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
@@ -433,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.0 → git_worktrees-0.2.3}/completions/gw.fish

@@ -19,5 +19,4 @@ complete -c gw -n 'not __fish_use_subcommand' -s q -l quiet -d 'less output'
 complete -c gw -n 'not __fish_use_subcommand' -s v -l verbose -d 'print every git command'
 complete -c gw -n 'not __fish_use_subcommand' -l explain -d 'print every git command and exit'
 
-complete -c gw -l version -d "show program's version number and exit"
 complete -c gw -s h -l help -d 'show this help message and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwa.fish

@@ -9,5 +9,4 @@ complete -c gwa -s q -l quiet -d 'the path alone'
 complete -c gwa -s v -l verbose -d 'print every git command'
 complete -c gwa -l explain -d 'print every git command and exit'
 
-complete -c gwa -l version -d 'show the version and exit'
 complete -c gwa -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwh.fish

@@ -2,5 +2,4 @@
 
 complete -c gwh -f
 
-complete -c gwh -l version -d 'show the version and exit'
 complete -c gwh -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwl.fish

@@ -11,5 +11,4 @@ complete -c gwl -s q -l quiet -d 'the path alone'
 complete -c gwl -s v -l verbose -d 'print every git command'
 complete -c gwl -l explain -d 'print every git command and exit'
 
-complete -c gwl -l version -d 'show the version and exit'
 complete -c gwl -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwm.fish

@@ -7,5 +7,4 @@ complete -c gwm -s q -l quiet -d 'the path alone'
 complete -c gwm -s v -l verbose -d 'print every git command'
 complete -c gwm -l explain -d 'print every git command and exit'
 
-complete -c gwm -l version -d 'show the version and exit'
 complete -c gwm -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwnb.fish

@@ -9,5 +9,4 @@ complete -c gwnb -s q -l quiet -d 'say nothing on success'
 complete -c gwnb -s v -l verbose -d 'print every git command'
 complete -c gwnb -l explain -d 'print every git command and exit'
 
-complete -c gwnb -l version -d 'show the version and exit'
 complete -c gwnb -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwp.fish

@@ -13,5 +13,4 @@ complete -c gwp -s q -l quiet -d 'verdicts only'
 complete -c gwp -s v -l verbose -d 'print every git command'
 complete -c gwp -l explain -d 'print every git command and exit'
 
-complete -c gwp -l version -d 'show the version and exit'
 complete -c gwp -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → 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'
@@ -14,5 +15,4 @@ complete -c gwr -s q -l quiet -d 'the path alone'
 complete -c gwr -s v -l verbose -d 'print every git command'
 complete -c gwr -l explain -d 'print every git command and exit'
 
-complete -c gwr -l version -d 'show the version and exit'
 complete -c gwr -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gwrot.fish

@@ -9,5 +9,4 @@ complete -c gwrot -s q -l quiet -d 'say nothing on success'
 complete -c gwrot -s v -l verbose -d 'print every git command'
 complete -c gwrot -l explain -d 'print every git command and exit'
 
-complete -c gwrot -l version -d 'show the version and exit'
 complete -c gwrot -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → git_worktrees-0.2.3}/completions/gws.fish

@@ -12,5 +12,4 @@ complete -c gws -s q -l quiet -d 'verdicts only'
 complete -c gws -s v -l verbose -d 'print every git command'
 complete -c gws -l explain -d 'print every git command and exit'
 
-complete -c gws -l version -d 'show the version and exit'
 complete -c gws -s h -l help -d 'show the help and exit'

{git_worktrees-0.2.0 → 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.0 → 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.0"
+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.0 → git_worktrees-0.2.3}/scripts/verify-publish.bash

@@ -34,21 +34,50 @@ echo "Verifying $NAME==$VERSION from $WHICH..." >&2
 TMP="$(mktemp -d)"
 trap 'rm -rf "$TMP"' EXIT
 
-# The version the installed script reports, compared against the one asked
+# An index accepts an upload before it serves it, and the delay differs between the JSON
+# API and the simple index resolved against here: 0.2.0 answered on the former while this
+# 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.
+#
+# 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
 # of the index. Running it and discarding the output would pass while every
 # command on the machine printed a number from a previous release.
-REPORTED="$(UV_CACHE_DIR="$TMP/cache" uv tool run \
-    --isolated \
-    --index "$INDEX" \
-    --index-strategy unsafe-best-match \
-    --from "$NAME==$VERSION" \
-    gws --version)"
+attempt=0
+delay="$BASE"
+while :; do
+    attempt=$((attempt + 1))
+
+    if REPORTED="$(UV_CACHE_DIR="$TMP/cache" uv tool run \
+        --isolated \
+        --index "$INDEX" \
+        --index-strategy unsafe-best-match \
+        --from "$NAME==$VERSION" \
+        gw version 2>"$TMP/resolve.err")"; then
+        break
+    fi
+
+    if [ "$attempt" -ge "$ATTEMPTS" ]; then
+        cat "$TMP/resolve.err" >&2
+        echo "$WHICH did not serve $NAME==$VERSION after $ATTEMPTS attempts." >&2
+        exit 1
+    fi
+
+    echo "waiting ${delay}s for $WHICH to serve $NAME==$VERSION (attempt $attempt/$ATTEMPTS)..." >&2
+    sleep "$delay"
+    delay=$((delay * 2))
+done
 readonly REPORTED
 
 [ "$REPORTED" = "$VERSION" ] || {
     echo "Version mismatch after publishing to $WHICH." >&2
     echo "  asked the index for: $VERSION" >&2
-    echo "  gws --version says:  $REPORTED" >&2
+    echo "  gw version says:     $REPORTED" >&2
     exit 1
 }