dotagents-cli 0.7.6__tar.gz → 0.8.1__tar.gz

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/CHANGELOG.md

@@ -7,6 +7,82 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-21
+
+### Added
+
+- Overlay commands get a launcher on `PATH`: each top-level `bin/<name>.py`, and
+  each `[scripts]` entry in `overlay.toml` (`name = "path"` adds or replaces one,
+  `name = false` opts a `bin/<name>.py` out). The launchers live in the agents'
+  venv, in `<venv>/overlays/`: `<name>.exe` on Windows, made with distlib's
+  `ScriptMaker` so no command interpreter parses the arguments, and a `/bin/sh`
+  script elsewhere. They run the script through `$<NAME>_OVERLAY_ROOT` when they
+  run, so only a new interpreter needs them made again. `init` and `overlays add` /
+  `sync` / `remove` keep them current and delete those no overlay has; two
+  overlays with one script name is an error naming both.
+- `dotagents env` puts the launcher directory of the venv `AGENTS_PYTHON` names
+  first on `PATH`, ahead of the levels' `bin` dirs, and takes any other venv's
+  off it.
+- A project gets its own venv when one of its overlays has scripts.
+- New dependency: `distlib>=0.4.0,<0.5`, vendored in the `.pyz`.
+
+## [0.8.0] - 2026-10-16
+
+### Added
+
+- `overlays add` takes globs: `overlays add '*' -g` installs every overlay the repos
+  offer, which for a store with a registry (`<store>/dotagents.toml`) is everything
+  it names. A glob matching nothing is an error.
+- `tools/cloud-setup.sh` installs every overlay the store's registry names
+  (`overlays add '*'`) before falling back to installing `private-sync` alone.
+
+- Each store has a Python venv, `<store>/.pyvenv/<X.Y.Z>-<os>-<arch>/`, made from
+  the Python that runs dotagents, where skills run. `init` and `overlays add` /
+  `sync` / `remove` keep it current: the user venv always has duho, and every
+  overlay's `requirements.txt` is installed (in one pip run, only when a file
+  changed, before the overlay's `setup.py`). A project gets its own venv when one of
+  its overlays ships requirements or a `lib/`. `--no-venv` skips it for a run;
+  `AGENTS_NO_PYVENV=1` turns it off. `.pyvenv/` holds the agents' venvs only: a
+  venv there that no sync completed is never used, and a project's own code keeps
+  its venvs in the project tree.
+- The venvs layer project > user > system through a `.pth` file in each: the store's
+  own overlay libs, then each lower store's venv packages and libs, then dotagents
+  itself. A project venv imports the project's packages first, then the user's.
+- `env` points `AGENTS_PYTHON` at the active venv and names it in `AGENTS_PYVENV`;
+  overlay `setup.py` scripts run under it. `context` prints it ("Python for
+  skills"), and its JSON form carries it as `python`. The managed block tells
+  agents to run skill scripts with `$AGENTS_PYTHON`.
+- pip without ensurepip: a venv where the interpreter has no ensurepip is created
+  without pip, and pip runs from its wheel (25.3, the last for Python 3.9, checked
+  against a pinned sha256). The wheel is found in the store's cache, in a `.pyz`
+  built with the new `build-pyz --with-pip`, in `AGENTS_PIP_SOURCE` (a directory of
+  wheels, or any URI pathapi-uri reads) or pip's `find-links`, or on your index
+  (`PIP_INDEX_URL`, or the mirror in `pip.ini` / `pip.conf`). `AGENTS_PIP_SOURCE`
+  is also passed to pip as `--find-links` for the requirements.
+
+### Changed
+
+- `overlays add` no longer stops at the first overlay that fails. Each failure is
+  logged, the overlays that require the failed one are skipped, every other overlay
+  is installed, and the command exits 1 naming each failure. A failed overlay this
+  run was installing for the first time is removed again, as before; the ones that
+  installed stay.
+- With a scope venv, `env` no longer puts the overlay libs it layers on
+  `PYTHONPATH`: the venv's interpreter imports them, and no other Python in the
+  session should. Without a venv, `PYTHONPATH` carries them as before.
+  `AGENTS_PYTHONPATH` still lists every lib.
+- The base block's "Startup: annotate that you read `…`" line names a store under
+  the home directory from there (`~/.agents/AGENTS.md`), and any other store by its
+  absolute path as before. A store kept in git and used on machines whose home
+  directories differ no longer shows `AGENTS.md` modified on all but one of them.
+
+### Fixed
+
+- `env --cache` on Windows with Python before 3.13 could miss a cache it had just
+  written: `time.time()` there lags the file's own timestamp by up to one clock
+  tick, and a cache file dated after "now" was treated as stale. A cache file
+  dated up to 2 s in the future now counts as fresh.
+
 ## [0.7.6] - 2026-10-15
 
 ### Added
@@ -1470,7 +1546,9 @@ Patch release: the PATH/POSIX-conversion fix above (the only change since 0.3.0)
   affected module sources (`dotagents.cli`, `duho.presets`) to extracted temp files
   before dispatch; a no-op for a plain install.
 
-[Unreleased]: https://github.com/jose-pr/dotagents/compare/v0.7.6...HEAD
+[Unreleased]: https://github.com/jose-pr/dotagents/compare/v0.8.1...HEAD
+[0.8.1]: https://github.com/jose-pr/dotagents/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/jose-pr/dotagents/compare/v0.7.6...v0.8.0
 [0.7.6]: https://github.com/jose-pr/dotagents/compare/v0.7.5...v0.7.6
 [0.7.5]: https://github.com/jose-pr/dotagents/compare/v0.7.4...v0.7.5
 [0.7.4]: https://github.com/jose-pr/dotagents/compare/v0.7.3...v0.7.4

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dotagents-cli
-Version: 0.7.6
+Version: 0.8.1
 Summary: The dotagents CLI: install and manage a portable ~/.agents config for AI coding agents
 Project-URL: Homepage, https://github.com/jose-pr/dotagents/
 Project-URL: Repository, https://github.com/jose-pr/dotagents
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
+Requires-Dist: distlib<0.5,>=0.4.0
 Requires-Dist: duho<0.8,>=0.7.5
 Requires-Dist: pathapi<0.2,>=0.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
@@ -215,6 +216,11 @@ store's shared `skills/` so every agent sees the same skills.
   `.ignore` at the overlay's root match (setup output, local state) and tool caches are left
   alone; `--prune` clears them too. A fresh `add` whose setup script fails is rolled
   back.
+- Each store has a Python venv, `<store>/.pyvenv/<version>-<os>-<arch>/`, where skills
+  run (`$AGENTS_PYTHON`): duho, every overlay's `requirements.txt` and every overlay
+  `lib/` import there, layered project > user > system. pip comes from the
+  interpreter, else its pinned wheel (cache, `AGENTS_PIP_SOURCE`, your index mirror,
+  or a `.pyz` built `--with-pip`).
 - `sync` refreshes each overlay from the repo it was installed from (`--repo` replaces
   that source), installs a `requires` added upstream, and re-merges the managed block.
 - `remove` deletes the overlay's directory, unpublishes only the skills **it**

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/README.md

@@ -160,6 +160,11 @@ store's shared `skills/` so every agent sees the same skills.
   `.ignore` at the overlay's root match (setup output, local state) and tool caches are left
   alone; `--prune` clears them too. A fresh `add` whose setup script fails is rolled
   back.
+- Each store has a Python venv, `<store>/.pyvenv/<version>-<os>-<arch>/`, where skills
+  run (`$AGENTS_PYTHON`): duho, every overlay's `requirements.txt` and every overlay
+  `lib/` import there, layered project > user > system. pip comes from the
+  interpreter, else its pinned wheel (cache, `AGENTS_PIP_SOURCE`, your index mirror,
+  or a `.pyz` built `--with-pip`).
 - `sync` refreshes each overlay from the repo it was installed from (`--repo` replaces
   that source), installs a `requires` added upstream, and re-merges the managed block.
 - `remove` deletes the overlay's directory, unpublishes only the skills **it**

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/docs/guide/authoring.md

@@ -72,12 +72,41 @@ dotagents starts with the libs in place whatever shell it runs from. A `lib/` mo
 comes before site-packages and the standard library: do not reuse a package name you
 do not mean to replace.
 
-A `bin/` launcher can also be run outside a `dotagents env` session (from cmd.exe or
-a PowerShell prompt, say), so it sets `PYTHONPATH` itself before starting Python:
-its own `lib/`, then `$AGENTS_PYTHONPATH`, then the caller's, leaving empty parts
-out (an empty entry means the current directory). The net overlay's `bin/curl` and
-`bin/curl.cmd` are the pattern: POSIX sh with no external commands, and a `.cmd`
-that uses `setlocal` so the caller's cmd session is not changed.
+## Commands on PATH: `bin/*.py` and `[scripts]`
+
+A Python command needs no launcher of your own. Every top-level `bin/<name>.py`
+gets one named `<name>`: `<name>.exe` on Windows (distlib's `ScriptMaker`, the
+launcher pip gives console scripts) and a `/bin/sh` script elsewhere, made in the
+agents' venv, in `<venv>/overlays/`, whenever `overlays add` / `sync` / `remove` or
+`init` brings the venv up to date. `dotagents env` puts that directory first on
+`PATH` for the venv `$AGENTS_PYTHON` names, so `bin/curl.py` answers to `curl`
+ahead of the system's, and drops any other venv's.
+
+The launcher runs your script under the venv's interpreter, as `python
+bin/<name>.py` would, found when it runs through `$<NAME>_OVERLAY_ROOT`: editing
+the script or moving the store needs nothing regenerated, only a new interpreter
+does. Unset, or with the script missing, it exits 2 and says so. A file whose name
+starts with `_` is not a command. Name other scripts, rename one, or opt one out
+in `overlay.toml`:
+
+```toml
+[scripts]
+tool = "lib/tool/main.py"   # a launcher `tool` for another path
+helper = false              # none for bin/helper.py
+```
+
+Two overlays with one script name is an error naming both. A launcher no overlay
+has any more is deleted at the next sync.
+
+**Never ship a `.cmd` or `.bat` that takes arguments.** cmd.exe parses its command
+line before the first line runs, so an argument's `&`, `|`, `>` or `%VAR%` acts:
+from PowerShell, `curl "http://h/?a=1|hostname"` would run `hostname`. The `.exe`
+above hands the arguments over as passed.
+
+Your script may run outside a `dotagents env` session too, so set `PYTHONPATH`
+for what it starts, if anything needs the libs: its own `lib/`, then
+`$AGENTS_PYTHONPATH`, then the caller's, leaving empty parts out (an empty entry
+means the current directory). The net overlay's `bin/curl.py` does this.
 
 ## Setup scripts
 

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/docs/guide/commands.md

@@ -100,10 +100,15 @@ dotagents init                          # base config into ./.agents (project sc
 dotagents init -g                       # ...into ~/.agents (user scope)
 dotagents init --bin-dir ~/.local/bin   # also write a `dotagents` command on PATH
 dotagents init --no-hooks               # skip agent hook wiring + the skills links
+dotagents init --no-venv                # skip the store's Python venv (duho for skills)
 dotagents init --agents claude,codex    # exactly these agents (default: detected + claude)
 dotagents init --dry-run
 ```
 
+`init` also creates or updates the store's Python venv, where skills run (see
+[the scope venv](overlays.md#python-dependencies-and-the-scope-venv)). Offline, or
+with no pip to be had, that is a warning; `overlays sync` retries.
+
 ### Hook wiring
 
 For each active agent, `init` adds what that harness needs to load the config, and
@@ -198,6 +203,7 @@ Manages opt-in overlays **by name**. See [Overlays](overlays.md) for the full mo
 
 ```bash
 dotagents overlays add python engineering  # install into the scope, publish skills, merge rules/routing
+dotagents overlays add '*' -g              # everything the repos offer (a store registry: all it names)
 dotagents overlays list                    # installed (discovered) + available from the repos
 dotagents overlays sync 'py*'              # refresh installed overlays matching a glob
 dotagents overlays sync --prune            # also clear what .gitignore/.ignore protect: exactly upstream
@@ -205,7 +211,14 @@ dotagents overlays remove python           # delete the overlay dir, unpublish i
 dotagents overlays show python             # describe one: manifest, requires, setup, skills, source (--json)
 ```
 
-- **`add`** installs what each manifest's `requires` names first, each requirement
+- **`add`** takes names or globs: `'*'` is every overlay the repos offer, so with
+  a store registry it installs everything the registry names, and `'py*'` the ones
+  starting with `py`; a glob that matches nothing is an error. One overlay failing
+  (its copy, requirements or setup) does not stop the rest: it is logged, what
+  requires it is skipped, everything else installs, and the command exits 1 naming
+  each failure. A failed overlay this run was installing for the first time is
+  removed again; one that was already installed is left in place, not set up.
+  `add` installs what each manifest's `requires` names first, each requirement
   installed and set up before the overlay that needs it (`--no-requires` to skip); a
   requirement the scope already has, in its own store or the user store for a project,
   is satisfied and left alone, while a name you ask for explicitly is always
@@ -213,8 +226,11 @@ dotagents overlays show python             # describe one: manifest, requires, s
   before touching anything — the first repo that offers a name wins — records where
   each overlay came from, and publishes skills from the installed copy, never
   replacing a skill already in the shared `skills/` dir (and links them into
-  Claude's skills dir when `init` wired Claude for the store). A fresh install whose setup
-  script fails is rolled back. A source inside the store's own `overlays/` directory
+  Claude's skills dir when `init` wired Claude for the store). Each overlay's
+  `requirements.txt` is installed into the scope venv before its setup script runs
+  (`--no-venv` skips it; see
+  [the scope venv](overlays.md#python-dependencies-and-the-scope-venv)). A fresh install
+  whose requirements or setup script fail is rolled back. A source inside the store's own `overlays/` directory
   is refused (by `sync` too): `remove` would delete the only copy.
 - `add`, `remove` and `show` without an overlay name are usage errors (exit 2), and
   a `--dry-run` says what it would write (`would recompose ...`) instead of reporting
@@ -590,6 +606,7 @@ is not listed.
 ```bash
 python -m dotagents build-pyz --out dist/dotagents.pyz
 python -m dotagents build-pyz --extras uri,repo     # also vendor what those extras install
+python -m dotagents build-pyz --with-pip            # also carry pip, for machines without it
 ```
 
 Builds a self-contained zipapp from a source checkout, with `duho` and `pathapi`
@@ -608,6 +625,9 @@ vendored (plus what the dotagents-cli extras named by `--extras` install), so it
   vendored as pure-Python wheels resolved for Python 3.9, so the file does not
   depend on the machine that built it; `sftp` needs native modules and fails the
   build with a message saying so. The archive is compressed.
+- `--with-pip` — also vendor the pinned pip wheel (about 1.8 MB), so the `.pyz` can
+  set up the scope venv where Python has no ensurepip and no index is reachable
+  (see [the scope venv](overlays.md#python-dependencies-and-the-scope-venv)).
 
 Each release attaches a built one:
 <https://github.com/jose-pr/dotagents/releases/latest/download/dotagents.pyz>.

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/docs/guide/overlays.md

@@ -48,7 +48,7 @@ or `--repo <checkout>/overlays` for a local checkout of the branch.
 | `python`, `node`, `rust` | Per-language `kb/` conventions + manifest templates + CI workflow templates. |
 | `release` | A host-agnostic release helper: an agent-driven commit-plan loop plus tag/CI monitoring across GitHub (`gh`) and GitLab. |
 | `private-sync` | The one-private-repo, per-project `.agents` model (`kb/PRIVATE_SYNC.md` + cloud hooks) — see [Private sync](private-sync.md). |
-| `net` | Dependency-free HTTP tooling (a drop-in `curl` shim, an OS-trust-store `certifi` shim, an `httplib` session toolkit reading `AGENTS_PROXY`). |
+| `net` | HTTP tooling: a drop-in `curl` launcher (curlike), an OS-trust-store `certifi` shim, and syshttp (the system proxy and the OS verifier by default), both packages installed from the overlay's `requirements.txt`; settings are `AGENTS_*` (`AGENTS_PROXY` and kin). |
 | `recovery` | A config-recovery playbook for reconstructing a lost `~/.agents`. |
 
 ## Managing overlays
@@ -182,7 +182,9 @@ dotagents overlays sync -g                                                   # r
 
 Nothing in an overlay has to set up its own paths. For every installed overlay,
 `dotagents env` prepends `bin/` to `PATH` and an existing `lib/` to `PYTHONPATH`
-(listing the libs in `AGENTS_PYTHONPATH` too), and exports **`$<NAME>_OVERLAY_ROOT`** — the overlay's
+(listing the libs in `AGENTS_PYTHONPATH` too), puts the launchers of its scripts
+(`bin/*.py` and `[scripts]`, in `<venv>/overlays/` of the agents' venv) first on
+`PATH`, and exports **`$<NAME>_OVERLAY_ROOT`** — the overlay's
 installed directory (`NAME` is the overlay's name upper-cased, `-` → `_`:
 `private-sync` → `PRIVATE_SYNC_OVERLAY_ROOT`).
 That variable is how overlay content refers to itself and to other overlays: a
@@ -214,6 +216,7 @@ small built-in reader that covers these keys. Keys:
 | `rules` | Overlay-relative markdown paths whose rule bullets append to "Always-on rules". |
 | `priority` | Merge order (lower sorts earlier; unprioritized default is 500). |
 | `setup_timeout` | Seconds the setup script may run before it is stopped (default 300; `0` = no limit). |
+| `[scripts]` | Launchers on `PATH`: `name = "path/in/overlay.py"` adds or replaces one, `name = false` drops the one for a `bin/<name>.py`. See [Authoring → Commands on PATH](authoring.md#commands-on-path-binpy-and-scripts). |
 
 `overlay.toml` is the only manifest. A leading `---` frontmatter block in a
 `CONTEXT.md` (the `priority:` / `scope:` / `dependencies:` an older overlay format
@@ -226,12 +229,49 @@ copies, where symlinks are unavailable) into the scope's shared skills dir, so e
 agent that reads that dir picks up the same skills. Removing the overlay unpublishes
 only the skills it published, then sweeps any now-broken symlinks.
 
+## Python dependencies and the scope venv
+
+Every store has a Python venv, `<store>/.pyvenv/<X.Y.Z>-<os>-<arch>/` (for example
+`~/.agents/.pyvenv/3.14.7-nt-arm64`), made from the Python that runs dotagents.
+A store's `.pyvenv/` holds these **agents' venvs only**: skills, overlay helpers and
+setup scripts run there. A project's own code gets its venvs beside the store, in
+the project root's `.pyvenv/` (`<project>/.pyvenv/<version>-<os>-<arch>/`, which the
+python overlay's `dotagents pyvenv` creates); only a venv dotagents itself synced is
+ever used as an agents' venv. `init` and every
+`overlays add` / `sync` / `remove` keep it current:
+
+- The user store's venv always has **duho**, so any skill can build a command line
+  on it, plus the packages each overlay installed there lists in a
+  **`requirements.txt`** at its root (pip's format). They are installed in one pip
+  run, so pip sees every constraint at once, and only when a file changed.
+- A project gets its own venv only when one of its overlays ships a
+  `requirements.txt` or a `lib/`; otherwise a project session uses the user venv.
+- The venvs **layer like everything else**. A `.pth` file in each venv lists, highest
+  precedence first: the store's own overlay libs, then the user venv's packages and
+  libs, then the system store's. dotagents itself comes last. So in a project venv,
+  the project's packages and libs win, then the user's, then the system's.
+- `dotagents env` points **`AGENTS_PYTHON`** at the active venv (and names it in
+  `AGENTS_PYVENV`). Overlay `setup.py` and `env.py` run under it, and the managed
+  block tells agents to run skill scripts with it. Libs the venv layers stay off
+  `PYTHONPATH`, so no other Python in the session, such as a project's own venv,
+  imports them by accident.
+
+**No ensurepip, no network?** pip runs from its wheel, pinned by version (25.3, the
+last for Python 3.9) and hash, found in this order: the store's cache, a copy
+vendored into the `.pyz` (`build-pyz --with-pip`), `AGENTS_PIP_SOURCE` (a directory
+of wheels, or any URI pathapi-uri reads: `file:`, `s3:`, `sftp:`, ...), pip's own
+`find-links`, then your index (`PIP_INDEX_URL` or the mirror in `pip.ini` /
+`pip.conf`). `AGENTS_PIP_SOURCE` is also handed to pip as `--find-links` for the
+requirements themselves.
+
+Opt out per run with `--no-venv`, or for good with `AGENTS_NO_PYVENV=1`.
+
 ## Setup scripts
 
 An overlay may ship an **idempotent** `setup.py` at its root — the recommended,
-OS-agnostic form: it runs under the same Python that runs dotagents, so it works on
-every platform. After `add` / `sync` copies the overlay
-in, dotagents runs the script automatically. Reserve it for real install-time work:
+OS-agnostic form: it runs under `AGENTS_PYTHON` (the scope venv above, with the
+overlay's requirements installed first), so it works on every platform. After
+`add` / `sync` copies the overlay in, dotagents runs the script automatically. Reserve it for real install-time work:
 `PATH`, `PYTHONPATH` and `$<NAME>_OVERLAY_ROOT` are `dotagents env`'s job
 (above), and an overlay's own env vars belong in its `env.py`, not in a script that
 writes one into the store — none of the example overlays ship a setup script any more.
@@ -242,8 +282,9 @@ Presence of a script is the opt-in; skip it with `--no-setup`. The author contra
 - **Environment** carries `AGENTS_HOME` (the user store), `AGENTS_SCOPE_ROOT` (the
   store the overlay is installed into), `AGENTS_SCOPE` (`user` or `project`) and
   `AGENTS_OVERLAY_DIR` (the overlay's own installed dir) — never hardcode a home path.
-- **Environment** is also the scope's assembled `dotagents env`: every overlay's `lib/`
-  on `PYTHONPATH`, its `bin/` on `PATH`.
+- **Environment** is also the scope's assembled `dotagents env`: every overlay's `bin/`
+  on `PATH`, and every overlay's `lib/` importable (through the venv's layering, or
+  `PYTHONPATH` without a venv).
 - **Time limit**: 300 seconds, or the manifest's `setup_timeout`, or the command's
   `--setup-timeout` (which wins); `0` means no limit. A script still running then is
   stopped, and that counts as a failure (exit 124).

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/docs/guide/private-sync.md

@@ -19,6 +19,16 @@ never lands in the public repo). `<name>` defaults to the project's basename, so
 local checkout and a cloud checkout of the same project resolve to the same store
 entry.
 
+The store's installed overlays can travel two ways:
+
+- **Tracked copies**: `overlays/` is committed. Every machine and cloud session has
+  them with the clone, offline; every `overlays sync` is a diff in the private repo.
+- **A registry**: `<store>/dotagents.toml` names one source per overlay and
+  `overlays/` is left out of the repo. `dotagents overlays add '*' -g` installs
+  everything it names, keeping going past one that fails; the bootstrap below runs
+  it in a cloud session. The repo stays small; each new machine fetches the
+  overlays once.
+
 ## Commands
 
 The overlay goes into the user store, since the store is what it syncs:
@@ -82,7 +92,8 @@ curl -fsSL https://raw.githubusercontent.com/<you>/dotagents/main/tools/cloud-se
     success. `&&` propagates the curl failure instead.
 
 The bootstrap authenticates (bypassing a hosted-runner `github.com` → proxy git
-rewrite), clones/pulls the store, installs the CLI, links the project, and wires the
+rewrite), clones/pulls the store, installs the CLI, installs every overlay the store's
+registry names (`overlays add '*'`, when it has one), links the project, and wires the
 hooks into `~/.claude/settings.json` — driven by `AGENTS_REMOTE` /
 `DOTAGENTS_AGENTS_TOKEN` / `DOTAGENTS_CLI_INSTALL` environment variables (the token is
 never committed). `AGENTS_OVERLAYS_REMOTE` / `AGENTS_OVERLAYS_REF` choose where it

{dotagents_cli-0.7.6 → dotagents_cli-0.8.1}/pyproject.toml

@@ -37,6 +37,8 @@ classifiers = [
 dependencies = [
     "duho>=0.7.5,<0.8",
     "pathapi>=0.1.0,<0.2",
+    # The launchers of overlays' [scripts]: ScriptMaker writes the Windows .exe.
+    "distlib>=0.4.0,<0.5",
     # overlay.toml manifests and TOML registries; tomllib is stdlib from 3.11.
     'tomli>=1.1.0; python_version < "3.11"',
 ]