@hanskristoffer/agentpool 0.13.0 → 0.15.0

package/README.md

@@ -31,6 +31,8 @@ Without npm:
 curl -fsSL https://raw.githubusercontent.com/HansKristoffer/agentgate/main/install.sh | sh
 ```
 
+Update a machine installed this way with `agentgate update`: it installs the latest release and restarts the service. `agentgate update <node>` does the same on a paired machine, and the app lists machines on an older release on the overview with an **Update** button under Machines. With npm, run `npm install -g @hanskristoffer/agentpool@latest` and `agentgate service restart`; the Mac app updates itself and its daemon.
+
 Or from source: `bun install && bun run build` (binaries land in `dist/`), or run `bun run cli -- …` directly.
 
 ## First machine
@@ -89,7 +91,7 @@ One instance per provider covers every account; the daemon switches eligible acc
 
 Start a thread on your laptop, hand it to an always-on server while you are away, and hand it back to test and push. A handed-off thread moves with its Claude session and its code: unpushed commits and uncommitted and untracked files (respecting `.gitignore`). Code travels directly between the two machines over Tailscale, or end-to-end encrypted through the relay; nothing is pushed to `origin`.
 
-Connect agentgate to the T3 Code on each machine once. In T3 Code open **Settings → Connections**, turn on **Network access** (T3 Code only offers pairing links while it is on), then under **Authorized clients** choose **Create link** with **Standard** permissions. Run `agentgate t3 connect <link>` within five minutes, then turn Network access off again if you like; agentgate connects over this machine only (on a headless server, `t3 pair` prints a token: `agentgate t3 connect --url http://127.0.0.1:3773 --token <token>`). The T3 Code page in the app has the same form under **Machines**. You can set up another machine from the one you are on: create the link in that machine's T3 Code, then paste it into its row under **Machines**, or run `agentgate t3 connect <link> --node srv`. The link travels to it over your paired connection, and that machine redeems it with its own T3 Code. Both machines need T3's Claude provider set to agentgate's `CLAUDE_CONFIG_DIR` (above), and must be paired over Tailscale or in the same relay group.
+Connect agentgate to the T3 Code on each machine once. In T3 Code open **Settings → Connections**, turn on **Network access** (T3 Code only offers pairing links while it is on), then under **Authorized clients** choose **Create link** with **Standard** permissions. Run `agentgate t3 connect <link>` within five minutes, then turn Network access off again if you like; agentgate connects over this machine only (on a headless server, `t3 pair` prints a token: `agentgate t3 connect --url http://127.0.0.1:3773 --token <token>`). The T3 Code page in the app has the same form under **Machines**. You can set up another machine from the one you are on: create the link in that machine's T3 Code, then paste it into its row under **Machines**, or run `agentgate t3 connect <link> --node srv`. The link travels to it over your paired connection, and that machine redeems it with its own T3 Code. The machines must be paired over Tailscale or in the same relay group. A handoff moves the session between the Claude homes T3 Code's Claude provider uses on each machine, whether that is `~/.claude` or the agentgate home above.
 
 ```sh
 agentgate threads                    # active threads on every machine
@@ -105,7 +107,7 @@ What to expect:
 - A working thread is stopped, moved, and continued on the other machine. On the source it is archived, and the uncommitted changes that were sent are kept in a `git stash` so the worktree is clean for the return trip. That stash is dropped when the thread comes back, because its changes come back with it.
 - The other machine reuses a worktree already on the thread's branch, or creates one and runs the project's setup script. Later trips reuse it, so setup runs once per branch and machine.
 - If the other machine's checkout has its own changes or commits, it keeps them and the handoff reports a warning. Your uncommitted changes then stay where they were.
-- The first time a thread arrives on a machine, T3 Code fails the first message you send it there. Send it again; the second one resumes the session. Threads that were working get this retry automatically, and later trips to the same machine reuse the thread without the failure.
+- The first time a thread arrives on a machine, T3 Code fails the first message sent to it there. agentgate sends that message for you, asking the agent to reply "Ready", and sends it again when it fails, so your own first message works. A thread that was working then gets "Continue where you left off." Background tasks such as a command watching a PR are stopped on the machine the thread leaves, and the agent is told which ones were running so it can start them again. Later trips to the same machine reuse the thread and skip this.
 - The first time a thread arrives on a machine, T3 Code's import also picks up other recent Claude sessions run in that project's main checkout, so threads that ran there can show up twice. Threads in worktrees are not affected, and later trips skip the import.
 - Through the relay, a handoff can move up to 512 MiB of code and session; the relay sees only encrypted data, its size and timing. Pair over Tailscale for larger repositories.
 - Claude Code threads only. Attachments, earlier turns' diffs and queued messages stay behind.
@@ -227,7 +229,7 @@ The app uses Tauri commands to send HTTP requests from Rust. It has no browser H
 
 See [running agentgate](docs/operations/running.md) for backup, upgrade, and live distribution checks. Account and MCP OAuth refreshes share holder coordination and a local cross-process lease. Running MCP shims reconnect after daemon restarts and update per-session mappings; tool calls with uncertain outcomes are never automatically replayed.
 
-Nodes use **sync protocol 5** (update every paired machine together) and the app checks **management API version 3** when connecting. Deletion history is retained so offline machines cannot resurrect old configuration.
+Nodes use **sync protocol 5** (update every paired machine together) and the app checks **management API version 4** when connecting. Deletion history is retained so offline machines cannot resurrect old configuration.
 
 `export --no-secrets` / **Without secrets** produces an inventory: it omits logins, OAuth client secrets, and arbitrary MCP URLs, headers, commands/arguments, environment, fields, and secrets. Restored inventory transports need configuration again. Full exports contain working credentials and transport configuration.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanskristoffer/agentpool",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "license": "UNLICENSED",
   "repository": {
     "type": "git",
@@ -22,9 +22,9 @@
     "agentgate": "bin/agentpool.js"
   },
   "optionalDependencies": {
-    "agentpool-darwin-arm64": "0.13.0",
-    "agentpool-darwin-x64": "0.13.0",
-    "agentpool-linux-x64": "0.13.0",
-    "agentpool-linux-arm64": "0.13.0"
+    "agentpool-darwin-arm64": "0.15.0",
+    "agentpool-darwin-x64": "0.15.0",
+    "agentpool-linux-x64": "0.15.0",
+    "agentpool-linux-arm64": "0.15.0"
   }
 }