@axelgar/opentree 0.2.0 → 1.0.1

package/README.md

@@ -6,12 +6,13 @@ Think [Conductor](https://conductor.build), but for the terminal.
 
 opentree is a cross-platform CLI tool that manages multiple AI coding agent sessions. Each session runs in an isolated git worktree with its own branch, orchestrated via tmux. Perfect for working on multiple features/fixes simultaneously without context-switching overhead.
 
-<img src="docs/demo.gif" alt="opentree — orchestrate parallel AI coding sessions in isolated git worktrees" style="width: 100%;max-width: 100%;">
+![opentree — orchestrate parallel AI coding sessions in isolated git worktrees](https://raw.githubusercontent.com/axelgar/opentree/main/docs/demo.gif)
 
 ## Features
 
 - **🌳 Isolated Workspaces**: Each workspace = git worktree + branch + tmux window
-- **🤖 Agent Integration**: Launch OpenCode (or other agents) automatically in each workspace
+- **🤖 Agent Integration**: Launch your agent automatically in each workspace
+- **💬 Built-in Chat**: Every agent speaks the [Agent Client Protocol](https://agentclientprotocol.com) and runs inside opentree's own chat view — answer permissions, watch diffs, send images, and drive the agent from the dashboard without attaching
 - **📊 TUI Dashboard**: Interactive terminal UI for managing workspaces (press `?` for help)
 - **🔀 Parallel Development**: Work on multiple branches simultaneously without checkout overhead
 - **📝 Diff Viewer**: Review changes before committing
@@ -26,8 +27,9 @@ opentree is a cross-platform CLI tool that manages multiple AI coding agent sess
 
 - **Git** (2.5+) - for worktree support
 - **tmux** (3.0+) - for session orchestration
-- **OpenCode** (optional) - default coding agent ([install](https://github.com/anomalyco/opencode))
+- **A coding agent** (optional) - OpenCode (the default), Claude Code, GitHub Copilot CLI or Gemini CLI
 - **GitHub CLI** (`gh`) (optional) - for PR creation and issue fetching ([install](https://cli.github.com/))
+- **Node** (optional) - only to run Claude Code through its ACP adapter
 
 ## Installation
 
@@ -75,6 +77,8 @@ opentree attach feat/add-auth    # Attach to tmux window
 opentree diff feat/add-auth      # Review changes
 opentree pr feat/add-auth        # Create GitHub PR
 opentree delete feat/add-auth    # Clean up workspace
+opentree skills list             # See every agent skill on this machine
+opentree skills sync             # Give every agent and workspace the repo's skills
 ```
 
 ## Usage
@@ -101,14 +105,180 @@ opentree
 - `p` - Create PR for selected workspace (auto-generates title and body from commits)
 - `o` - Open PR in browser
 - `x` - Delete selected workspace (shows diff confirmation if uncommitted changes)
+- `R` - Send the workspace's open PR review comments to its agent
+- `w` - Start or stop the workspace's dev server
+- `b` - Jump to the workspace that has been waiting longest on a permission (press again to cycle)
 - `space` - Toggle multi-select on current workspace
 - `/` - Filter workspaces by name
 - `s` - Cycle sort order (name → age → activity → PR)
 - `E` - Toggle error log
+- `tab` - Switch between Workspaces, Skills and Servers
 - `?` - Toggle full help
 - `q` - Quit
 
-The TUI also shows a live **agent output preview** for the selected workspace and **CI check status** badges for open PRs.
+Each row also carries what its agent is doing — working, waiting on a
+permission, stopped — plus cost and context use, read live from the chat's
+control socket. Open PRs show **CI check status** badges.
+
+### Skills
+
+Skills are a filesystem convention rather than anything an agent exposes over
+its API — a directory holding a `SKILL.md` — so opentree reads them directly.
+Press `tab` for the inventory: every skill on the machine, which agents can
+actually use each one, and what each agent will do with it.
+
+- `enter` - Open the SKILL.md in `$EDITOR`
+- `a` - Add a skill from a git URL
+- `c` - Copy a skill into another agent's directory
+- `x` - Delete a skill
+- `t` - Switch a skill off for the agents that can be told
+- `l` - Link the repository's skills to every agent and workspace that is missing them
+- `v` - Ask the agent itself what it loaded, and flag anything the list got wrong. Gemini keeps its skills out of the protocol, so it cannot be asked
+
+A `git worktree` carries only what git tracks, and most repositories leave
+their skills untracked — so opentree links the repository's skills into each
+workspace it creates. `opentree skills sync` repairs workspaces that predate
+this, and `opentree skills list` prints the same inventory for a script.
+
+### Talking to the agent
+
+opentree talks to agents over the [Agent Client Protocol](https://agentclientprotocol.com)
+(ACP) and draws the conversation itself, rather than handing the tmux window to
+the agent's own TUI. You get the same worktree-per-branch
+flow, but the agent's turns, tool calls, diffs, what each tool printed, and
+permission prompts are rendered by opentree, which means the dashboard knows
+what every agent is doing without scraping its output.
+
+Press `Enter` on a workspace to attach to its chat:
+
+```
+ fix-auth  ◆ OpenCode                             claude-sonnet-4.6 · plan · 12% ctx · $0.0431
+
+┃ add a rate limiter to the login handler
+
+◆ Adding one keyed by client IP, and a test for the burst case.
+   ✓ grep -rn rate.Limiter pkg/
+     pkg/api/throttle.go:14: var limiter = rate.NewLimiter(rate.Every(time.Minute), 60)
+   ✓ pkg/auth/login.go  +18 -2
+     + limiter := rate.NewLimiter(rate.Every(time.Second), 5)
+   ⠹ go test ./pkg/auth/
+
+ ╭──────────────────────────────────────╮
+ │ go test ./pkg/auth/                  │
+ │ [a] Allow once                       │
+ │ [A] Always allow                     │
+ │ [d] Reject                           │
+ ╰──────────────────────────────────────╯
+ permission needed · esc to cancel
+```
+
+Each agent has its own mark and colour — `◆` for OpenCode, `✻` for Claude Code,
+`◉` for GitHub Copilot, `✦` for Gemini CLI —
+so the chat header and every workspace row in the dashboard say which agent you
+are dealing with without being read word by word. An empty chat opens on the
+agent's own logo, in its own colours:
+
+```
+ ▐▛███▜▌    Claude Code
+▝▜█████▛▘   fix-auth
+  ▘▘ ▝▝     ~/src/myrepo/.opentree/fix-auth
+```
+
+| Key | |
+| --- | --- |
+| `enter` | send |
+| `ctrl+j` | newline |
+| `/` | slash commands — the agent's own, plus `/resume`, `/login`, `/model` and the rest |
+| `@` | attach a file from this worktree |
+| `ctrl+v` | paste — an image on the clipboard is attached, anything else is text |
+| `esc` | interrupt the current turn |
+| `shift+tab` | cycle the agent's mode (plan / build / …) |
+| `ctrl+g` | settings — model, reasoning effort, anything else the agent declares |
+| `ctrl+o` | show or hide the agent's reasoning |
+| `?` | every key |
+
+**Images.** Press `ctrl+v` to attach a screenshot from the clipboard, or drag one
+onto the terminal. Either way the path collapses into `[image · shot.png · 412 KB]`
+in the message you are writing — backspace over it and the attachment goes with
+it — and it travels to the agent as a real image block. On macOS
+that is `ctrl+v` and not `cmd+v`: `cmd+v` is the terminal's own paste, and a
+terminal asked to paste a picture sends nothing at all. An agent that does not
+take images gets the path as a link instead, and the chat says so rather than
+letting the difference go unnoticed.
+
+**Earlier conversations.** `/resume` lists what this worktree has already
+talked about — newest first, by what each conversation was about — and picking
+one reopens it in place, history and all. The list is the agent's own where it
+keeps one, merged with what opentree recorded itself, so the command works the
+same whichever agent is running.
+
+The agent's live model, mode and effort sit on the right of the input, next to
+the running context and cost. `ctrl+c` takes you back to the workspace list and
+leaves the chat running: the agent keeps working, its row keeps reporting, and
+attaching again drops you straight back into the conversation.
+
+**From the dashboard.** You don't have to attach to drive a chat. With a
+workspace selected, `m` sends it a prompt, `a` answers a pending permission
+request, and `c` interrupts the current turn — the row shows what the agent is
+doing, what it's waiting on, and what it has cost. A prompt sent to a busy agent
+is queued rather than refused.
+
+**Which agents.** OpenCode, GitHub Copilot CLI and Gemini CLI serve ACP
+themselves, so having the binary is the whole setup. Claude Code is reached
+through the `claude-agent-acp` adapter, which opentree installs on request into
+`~/.opentree/tools` rather than your global npm root — press `A` in the
+dashboard, pick Claude Code, and it offers the download (303MB, needs `node`).
+
+Those four are the whole list. opentree drives agents over ACP and nothing else,
+so an agent without an ACP server has no way in — if one ships support, it
+becomes a single registry entry and everything above applies to it unchanged.
+
+### Notifications
+
+The cost of running four agents at once is that idleness becomes invisible: the
+one workspace blocked on a permission prompt looks exactly like the three that
+are working, unless you are staring at the list. So each chat says something
+when it starts needing you:
+
+| Event | |
+| --- | --- |
+| `blocked` | the agent stopped to ask for a permission |
+| `done` | a turn finished |
+| `stopped` | the agent died, failed to start, or its setup commands failed |
+
+Two surfaces. In tmux the window's own bell rings, which tmux renders as an
+inverted window name in the status bar until you select that window — no
+configuration, and it clears itself. Outside the terminal, a desktop banner
+(`osascript` on macOS, `notify-send` on Linux) reaches you with the terminal
+behind a browser or closed.
+
+Nothing is sent while you are looking at the window it happened in, and nothing
+at all when the chat is not running inside tmux. The banners are signposts
+rather than buttons: pressing `b` in the dashboard is what takes you to the
+workspace that has been waiting longest, and pressing it again walks the rest.
+Each waiting row says how long it has been at it — `blocked 12m`.
+
+```bash
+opentree notify test          # one of each, through the surfaces you have
+```
+
+Worth running once: macOS silently drops notifications sent by `osascript`
+until they have been allowed, which is otherwise a feature with no symptom.
+
+```toml
+[notify]
+on      = ["blocked", "stopped"]   # add "done"; [] switches everything off
+desktop = true                     # false: tmux bell only
+```
+
+`blocked` and `stopped` are on by default and `done` is off, because four agents
+finishing turns is a banner every ninety seconds — and a notifier you mute is a
+notifier you deleted.
+
+This section is read from `~/.config/opentree/opentree.toml` only. A repository's
+own `opentree.toml` may configure how the project is built; how you like to be
+interrupted is yours, and a cloned repository does not get to start sending you
+desktop banners.
 
 ### CLI Mode (Direct Commands)
 
@@ -177,6 +347,17 @@ opentree pr feat/user-auth --title "Add user auth" --body "..." # Non-interactiv
 
 Requires GitHub CLI (`gh`) to be authenticated.
 
+#### Send PR Reviews to the Agent
+
+```bash
+opentree review <branch-name>
+```
+
+Fetches the open PR's review comments and sends them to the workspace's agent as
+a prompt, over the chat's control socket. The chat has to be running, but it
+doesn't have to be the window you're looking at — and if the agent is mid-turn
+the command says so rather than reporting a send that went nowhere.
+
 #### Delete Workspace
 
 ```bash
@@ -206,101 +387,194 @@ base_dir = ".opentree"        # Where to store worktrees (relative to repo root)
 default_base = "main"         # Default base branch
 
 [agent]
-command = "opencode"          # Command to launch agent
-args = []                     # Additional arguments
+command = "opencode"          # Agent to run: "opencode", "claude", "copilot" or "gemini"
+
+[workspace]
+seed  = [".env", ".npmrc"]                  # Untracked files to link into each new worktree
+setup = ["pnpm install --frozen-lockfile"]  # Commands run before the agent starts
+run   = "pnpm dev"                          # Dev server, started on demand, PORT exported
 
 [tmux]
 session_prefix = "opentree"   # Prefix for the tmux session name
 
 [github]
 auto_push = true              # Push branch before creating a PR (set false to push manually)
+
+[notify]                      # Global config only — see Notifications
+on      = ["blocked", "stopped"]
+desktop = true
 ```
 
-### Using Different Agents
+### Seeding a Worktree
 
-To use a different coding agent instead of OpenCode:
+A git worktree carries only what git tracks, so a fresh one has no `.env` and no
+`.npmrc` — and the agent's first turn goes on discovering that. List the
+untracked files a worktree needs and opentree links them in as it creates one:
 
 ```toml
-[agent]
-command = "claude"            # Or "aider", "cursor", etc.
-args = ["--some-flag"]
+[workspace]
+seed = [".env", ".npmrc", "config/local.json"]
+```
+
+Each entry is a path relative to the repository root, and it lands at the same
+path inside the worktree. They are symlinks rather than copies: one credential
+set, shared, so rotating a token in the repository rotates it in every worktree
+instead of in one out of five.
+
+Files only. A directory is refused — `node_modules` is the output of an install,
+not a file to link, and a worktree that deletes a linked one has just emptied
+your main checkout's. A path that leaves the repository, by `..` or through a
+symlink, is refused when the workspace is created rather than seeded quietly.
+
+A file the repository does not have is skipped, and one the branch tracks itself
+is left alone: git checking it out is the signal that the branch has its own.
+
+When one branch has to change a shared file, detach it — the link becomes that
+worktree's own copy, keeping what was in it:
+
+```bash
+opentree seed detach feat/add-dark-mode .env
+```
+
+That can also happen by accident: tools that save by renaming over a file
+replace the link with an ordinary one. `opentree setup <branch> --check` reports
+which seeded files are still linked and which have quietly detached.
+
+### Setting Up a Worktree
+
+Seeding puts config where git could not. Setup is the other half — what has to
+be built rather than copied:
+
+```toml
+[workspace]
+setup = ["pnpm install --frozen-lockfile"]
 ```
 
-### Agent status signals
+The commands run as the first phase of the chat, in the worktree, with their
+output streaming into the window. The agent starts when they finish. That is the
+point of running them there: an agent that starts against a worktree with no
+`node_modules` spends its first turn discovering it, and may "fix" your lockfile
+on the way.
 
-Agents can tell opentree how they're doing by writing a `.opentree-status.json`
-file to the **worktree root**. The workspace list reads it on every refresh and
-shows a badge, so a glance across the dashboard tells you which worktrees are
-working and which have gone quiet and want your attention.
+While they run the dashboard shows the workspace as `setting up…`. Nothing is
+timed out — a warm install is two seconds and a cold `cargo build` is twenty
+minutes — so `esc` is how a hung one ends, and it stops the whole process tree
+rather than just the shell. If a command fails, the panel offers `[r]` to try
+again and `[s]` to start the agent anyway, and the failure is recorded in the
+dashboard's error log (`E`). It is never pasted into the conversation: whether
+the agent should see it is your call.
 
-```jsonc
-{
-  "status": "needs_input",              // required: "in_progress" or "needs_input"
-  "message": "Approve running tests?"   // optional — shown on the row
-}
+Setup runs once per worktree. It runs again when you edit the commands, and not
+otherwise — losing a chat window relaunches one, and reinstalling on every attach
+would make attaching cost a minute.
+
+Not sure what to put in the block? opentree will read the project and propose
+one, from `package.json` or a `Procfile`:
+
+```bash
+opentree setup --suggest
 ```
 
-Agents only ever report two things — `in_progress` (a turn started) and
-`needs_input` (a turn ended, or it hit a prompt). opentree pairs that with **how
-long ago** the file last changed to derive the badge, so a finished turn from an
-hour ago doesn't look the same as one that just landed:
+It prints; it never writes. What lands in `opentree.toml` is committed, runs on
+every machine that clones the repository, and is approved by a prompt that means
+nothing if opentree wrote the thing being approved.
 
-| Agent wrote   | Last change      | Badge                | Meaning                              |
-| ------------- | ---------------- | -------------------- | ------------------------------------ |
-| `in_progress` | recent           | `working…`           | actively generating                  |
-| `in_progress` | stale            | `stalled · 40m ago`  | turn never ended — likely dead session |
-| `needs_input` | recent           | `waiting · your turn`| just stopped — your move             |
-| `needs_input` | stale            | `idle · 2h ago`      | parked; nobody's touched it          |
+To repair a worktree, or run a setup you skipped, without restarting a chat and
+tearing down a live conversation:
 
-The status bar tallies the ones that want you: `N waiting` and, if any, `N stalled`.
+```bash
+opentree setup feat/add-dark-mode           # re-seed, then run the commands here
+opentree setup feat/add-dark-mode --check   # report what is seeded and what has run
+```
+
+Both paths write the same marker, so a worktree prepared from the terminal is one
+the chat will not prepare again.
 
-Pane activity also rescues a stuck badge in both directions: a long-running
-`in_progress` with a quiet status file but a still-active pane stays
-`working…` instead of reading `stalled`, and a `needs_input` with pane output
-*after* the status write (e.g. you approved a permission prompt, which isn't
-a new top-level message) reads `working…` again instead of staying wedged on
-`waiting`.
+#### Approving what it runs
 
-**One-step setup.** Let opentree install the hooks for you:
+`opentree.toml` is tracked in git, so `setup` and `run` are executable code that
+arrives with a clone, from whoever last had commit rights. opentree asks before
+running them the first time, in the chat, showing exactly what it is about to
+run. The answer is recorded per machine, per repository, and per exact text — an
+edited command is asked about again.
+
+From the command line, for CI or to answer ahead of time:
 
 ```bash
-opentree agents setup claude   # or: codex, gemini, opencode
-```
-
-This merges the guarded status hooks into the agent's user-level config
-(`~/.claude/settings.json`, `~/.codex/hooks.json`, `~/.gemini/settings.json`, or
-an OpenCode plugin), backing up any existing file first. It's idempotent — safe
-to re-run. opentree exports `OPENTREE_STATUS_FILE` into every agent shell it
-launches, so the hooks write to the right worktree and stay inert (a no-op) in
-any session opentree didn't start. That means you install once, globally, and it
-just works across all your worktrees.
-
-`opentree agents setup <agent>` maps a new prompt and a completed tool call →
-`in_progress`, and a permission prompt / notification / turn-end →
-`needs_input`. The tool-completion hook is what flips the badge back to
-`working…` after you approve a permission prompt mid-turn, since that isn't a
-new prompt itself. The bundled hooks report `status` only; the optional
-`message` is for hand-written or custom hooks.
-
-**GitHub Copilot** and **Pi** can't be fully automated (Copilot has no
-"waiting for input" event; Pi's notify config holds a single script) — running
-`opentree agents setup gh` / `pi` prints tailored manual instructions.
-
-**Manual wiring / other agents.** Any agent can drive the badge by writing the
-status file itself. Point it at `$OPENTREE_STATUS_FILE` (exported by opentree),
-e.g. a Claude Code hook in `~/.claude/settings.json`:
-
-```jsonc
-{
-  "hooks": {
-    "UserPromptSubmit": [{ "hooks": [{ "type": "command",
-      "command": "[ -n \"$OPENTREE_STATUS_FILE\" ] && printf '{\"status\":\"in_progress\"}' > \"$OPENTREE_STATUS_FILE\"" }] }],
-    "Notification": [{ "hooks": [{ "type": "command",
-      "command": "[ -n \"$OPENTREE_STATUS_FILE\" ] && printf '{\"status\":\"needs_input\"}' > \"$OPENTREE_STATUS_FILE\"" }] }]
-  }
-}
+opentree trust          # approve what opentree.toml now says
+opentree trust show     # print those commands, and whether they are approved
+opentree trust revoke   # drop this repository's approvals
+```
+
+Approvals live in `~/.opentree/trust.json`, never in the repository — a
+repository cannot vouch for itself.
+
+### Dev Servers
+
+Five worktrees of one project all want port 3000. Give opentree the command and
+each gets a port of its own instead:
+
+```toml
+[workspace]
+run = "pnpm dev"
 ```
 
+`opentree prune`, which already reaps workspaces whose worktree was deleted
+outside opentree, also stops server windows with no workspace left behind them.
+
+Servers start on demand, never on creation — five worktrees each running
+`next dev` is several gigabytes nobody asked for. Press `w` on a workspace row
+to start or stop one, or open the **Servers** tab (`tab`) for the full list:
+every workspace, what its server is doing, and its address.
+
+Each workspace is assigned a port between 20000 and 32000 once, and keeps it —
+so an OAuth redirect URI registered against `localhost:20431` keeps working. The
+port arrives as `PORT`; opentree never rewrites your command, so a stack that
+ignores `PORT` can be told `--port $PORT` in the command itself.
+
+The server runs in its own tmux window (`<branch>:run`), so `enter` in the
+Servers tab attaches to it and all of its output is there. Deleting a workspace
+stops its server.
+
+#### Names instead of ports, with portless
+
+If [portless](https://github.com/vercel-labs/portless) is installed and its
+proxy is running, opentree starts servers behind it and the Servers tab shows
+`https://<branch>.<repo>.localhost` — which reads as "this branch of this
+project" — with the port still listed beside it.
+
+The name is passed explicitly rather than left to portless's own inference,
+which reads `package.json` or the git root and so infers the same name for every
+worktree of one repository.
+
+opentree never installs or starts portless itself. Getting its proxy running
+means a certificate authority, an `/etc/hosts` entry and a root-owned service,
+and it asks for those with a sudo prompt — which in a detached tmux window
+nobody would see. If portless is installed but its proxy is down, the tab says
+so and serves on ports meanwhile.
+
+### Using Different Agents
+
+To use one of the others instead of OpenCode:
+
+```toml
+[agent]
+command = "claude"            # or "copilot", or "gemini"
+```
+
+Or press `A` in the dashboard to pick from the agents you have installed — it
+writes the same config, and offers to fetch the ACP adapter if the agent needs
+one. From the CLI:
+
+```bash
+opentree agents list           # what's installed, and which is active
+opentree agents use claude     # switch this repo (--global for everywhere)
+opentree agents setup claude   # fetch its ACP adapter, if it needs one
+```
+
+An agent opentree has no ACP spec for is refused up front, when you create a
+workspace, rather than later inside a chat that cannot start.
+
 ## How It Works
 
 1. **Worktrees**: Git worktrees allow multiple checkouts of the same repo in different directories. Each workspace lives in `.opentree/<branch-name>/`.
@@ -311,6 +585,8 @@ e.g. a Claude Code hook in `~/.claude/settings.json`:
 
 4. **Agent Integration**: When creating a workspace, opentree launches your configured agent inside the tmux window, ready to code. With no agent configured, it uses the first supported agent found on your PATH.
 
+5. **The Chat**: The tmux window runs `opentree chat`, never the agent's own TUI. It holds one JSON-RPC connection to the agent over stdio and renders the conversation, so opentree sees every turn, tool call and permission request as structured data instead of scraped terminal output. The dashboard reaches a running chat over a Unix socket, which is how `m`, `a` and `c` work without attaching. Session IDs are kept in `state.json` so conversations survive closing the window.
+
 ## Workflow Example
 
 ```bash
@@ -362,6 +638,30 @@ opentree sets the agent's environment via `tmux new-window -e`, which needs tmux
 
 Install OpenCode from [github.com/anomalyco/opencode](https://github.com/anomalyco/opencode), or configure a different agent in `opentree.toml`.
 
+### The chat says the agent needs an adapter
+
+Claude Code speaks ACP through `claude-agent-acp`. Press `A` in the dashboard,
+select Claude Code, and accept the download — it installs to `~/.opentree/tools`
+and needs `node` on your PATH. If you already have the package installed
+globally, opentree uses that instead of fetching a second copy.
+
+### The chat says the agent needs credentials
+
+The chat's stopped panel offers `[l]`. What that does depends on how the agent
+logs in, and opentree takes the agent's word for it in this order: a command the
+agent names itself (Copilot sends its own path and `login`), the command opentree
+has recorded for it (`opencode auth login`, `claude auth login`), or the login
+performed over the protocol. Gemini CLI takes the last route and offers four
+ways in — Google account, Gemini API key, Vertex AI, gateway — so `[l]` opens a
+picker. A terminal login hands the window to the agent and restarts it when it
+finishes; a protocol login happens inside the running agent and needs no restart.
+
+Credentials also go wrong while an agent is perfectly happy to answer: a token
+expires, a key is revoked, a login lands on the wrong account. `/login` reaches
+the same picker mid-conversation, and the conversation survives it.
+
+Anything else that stops an agent offers `[r]` to restart it.
+
 ### "Error: gh not found"
 
 Install GitHub CLI from [cli.github.com](https://cli.github.com/), then authenticate:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axelgar/opentree",
-  "version": "0.2.0",
+  "version": "1.0.1",
   "description": "Git worktree manager CLI for orchestrating parallel AI coding sessions",
   "repository": {
     "type": "git",
@@ -15,10 +15,10 @@
     "bin/opentree"
   ],
   "optionalDependencies": {
-    "@axelgar/opentree-linux-x64": "0.2.0",
-    "@axelgar/opentree-linux-arm64": "0.2.0",
-    "@axelgar/opentree-darwin-x64": "0.2.0",
-    "@axelgar/opentree-darwin-arm64": "0.2.0"
+    "@axelgar/opentree-linux-x64": "1.0.1",
+    "@axelgar/opentree-linux-arm64": "1.0.1",
+    "@axelgar/opentree-darwin-x64": "1.0.1",
+    "@axelgar/opentree-darwin-arm64": "1.0.1"
   },
   "engines": {
     "node": ">=18"