# CLI changelog

Source: https://pushary.com/docs/agents/reference/cli-changelog
Last updated: 2026-11-18

> What changed in each release of the Pushary CLI, newest first

This is the changelog that ships inside the CLI package on npm, published as [`pushary`](https://www.npmjs.com/package/pushary) and as `@pushary/agent-hooks`. Both names carry the same build. A change on the server or in Pushary for Mac can change what your agents see without a CLI release. Those changes are in the [changelog](/docs/changelog) and the [Pushary for Mac release notes](https://github.com/Pushary/pushary-mac/releases).

# Changelog [#changelog]

## 1.9.206 [#19206]

* Doctor reports an inconclusive version check when npm cannot verify which release the machine may install.

## 1.9.205 [#19205]

* On Windows, Hermes 1.0.6 finds its history helper through the Hermes process PATH. Setup keeps the global helper installation and skips the saved command record there.

## 1.9.204 [#19204]

* Windows setup forwards each argument separately when starting a release selected by npm policy.

## 1.9.203 [#19203]

* When the server and answering client send text-entry provenance, the hook returns a typed `defer` as the answer. The handoff button and older clients keep their existing behavior.

## 1.9.202 [#19202]

* A Codex edit under a path rule that approves on timeout, such as `Edit(src/**)`, no longer runs without anyone being asked. The hook matched the rule on the file's real path, but asked the server about the edit by its extension alone, so the server judged it by the bare `Edit` rule. Past the eight-question cap the server then stored the approval without a push, and in a session paused after three unanswered approvals it paused it; either way the hook let the call run as if its window had passed. The hook now sends the path it matched, and for a multi-file patch the file whose rule governs the whole patch, with the working directory relative rules resolve against.
* A Codex call is no longer approved on timeout unless its question was pushed and its whole window ran. A question the session pause held back, or one the server stored past the push cap, is refused when nobody answers, as an unanswered call under any other rule is. At a Codex permission prompt such a call goes to Codex's own confirmation instead of being allowed.
* Because the server now sees the file a Codex edit touches, these edits behave as the same edits already did through the Mac app and the editor gates:
  * A Team approval route written for a path, such as one for `Edit(infra/**)`, now sends a Codex edit under that path to the people it names. Before, only a route matching the file's extension could apply.
  * An edit under a path rule that approves on timeout now rings the phone every time, as every question whose silence would approve the call does. After 10 such routine edits in a row go unanswered, it rings at most once every 10 minutes and arrives silently otherwise.
  * Past the eight-question cap, an edit under a path rule that approves on timeout is no longer stored without a push and then run. It waits for a free place for as long as its own window still fits, and if none frees, it is refused with the question limit reason.
  * A scope breach under a path rule that approves on timeout is refused at the cap with its scope reason, instead of being stored without a push and refused after its window.
* One case still approves after the window: a question the server holds back as test traffic is still treated as delivered, so a rule that approves on timeout runs the call once its window ends.

## 1.9.201 [#19201]

* When the policy request fails or runs out of time, the quick check Pushary runs on read-only and MCP tool calls now says that it checked your refusal rules against an older copy of your policy. It prints a `[degraded]` line on the hook's stderr and sends Pushary a report with the age of that copy, at most once a minute from each computer when `~/.pushary` is writable and from each hook process when it is not. Sending a report can keep the hook process alive up to one more second. What the check decides is unchanged.
* What that older copy covers, stated more precisely than in 1.9.194: it is the last policy this session saved, or else the last one any session on this computer saved, from up to 12 hours ago and whatever its version. A refusal rule you add after that copy was saved is not applied, and a rule you delete since then keeps refusing until a policy request succeeds again. With no copy from the last 12 hours, the call runs without the check and the failure is reported, as before. The kill switch does not depend on this copy.

## 1.9.200 [#19200]

* Setup's agent question no longer sets up an agent you unticked. Since 1.9.186, when no key was pressed there for 20 seconds, setup used the agents it detected, even if you had changed the ticks first. An agent you unticked was set up anyway, and an agent you ticked by hand was left out. Now, if you pressed any key, setup uses exactly what is ticked on screen when the 20 seconds run out, and says so. Each key still restarts the 20 seconds. If nothing is ticked, setup configures no agents, keeps your key, says how to finish, and exits with code 5; when no agent was detected either, it says so, as before. If no key was pressed at all, setup uses the detected agents as before, so an agent running setup in a terminal still never waits forever. `--agents`, `--yes`, `--json` and runs with nobody at the terminal are unchanged.

## 1.9.199 [#19199]

* When setup finishes and has reached your phone, it gives you one thing to try: a line to paste into a new agent session that has the agent ask you a multiple-choice question through Pushary and wait for your answer. It appears only when nothing still needs fixing and at least one agent with a Pushary question tool was set up.
* The bundled Pushary skill now tells agents to let you type your own answer to a choice question (`allowOther: true`) unless their options cover every answer. The Other box shows on the pushary.com decision page and in the Android app from 1.0.64; the iOS app gets it with 1.0.65. Other places you answer show the options as before.

## 1.9.198 [#19198]

* Hermes session history now works without the Pushary Mac app, in Hermes Desktop, the `hermes` CLI and the gateway service. Setup for Hermes used to skip the global install, so the history helper was missing, and a Hermes gateway started by systemd could not find it on `PATH` anyway. With session history on, `npx pushary@latest setup --agents hermes` now installs the CLI globally and records the Node runtime and the helper's absolute path in `~/.pushary/hermes-history-helper.json`, which the bundled Hermes plugin (1.0.5) reads before `PATH`. A Homebrew Node is recorded by its stable path, so `brew upgrade node` does not break it.
* If you set up Hermes with an earlier release, run `npx pushary@latest setup --agents hermes` once more: earlier releases did not install the CLI globally, so there is nothing for `pushary upgrade` to upgrade. Where the CLI is already installed globally for another agent, `pushary upgrade` (or the automatic update on macOS) writes the record when it refreshes the plugin. Restart Hermes afterwards so it loads plugin 1.0.5.
* If the global install fails, Hermes is still connected. Setup records a global Pushary CLI that is already installed, and otherwise prints the fix for that failure, for example how to point npm at a folder you can write to. Nothing changes when the Mac app handles history on this computer. Verified on macOS and Linux. Windows follows the same rules but has not had a run of its own yet.

## 1.9.197 [#19197]

* Hermes conversations can now reach your phone on a Mac where the Pushary app has Session history on and Hermes uses the app's Pushary key. Hermes plugin 1.0.3 and earlier looked for the app's history helper in `~/.pushary/bin`, where the app never puts it, so Hermes history was never saved there. The bundled plugin (1.0.4) finds the helper inside Pushary.app. A copy the Mac app installed updates with the next Mac release. A Hermes without its Pushary key no longer logs that the history reader could not start.

## 1.9.196 [#19196]

* The bundled Hermes plugin (1.0.3) includes the marketplace quickstart: connect your phone, ask one test question and check the answer. Approval behavior is unchanged.

## 1.9.195 [#19195]

* Session history now reaches your phone for a session Pushary had no record of, for example one whose start never reached the server. The server used to refuse every upload for such a session, and history kept retrying once a minute for up to two days without saving anything. After the first refusal, the next upload names the agent and the project folder, and the server records the session then. A session the server already knows is unchanged.
* When the server says it holds no key for a session, history offers the session's key again instead of waiting for one that never arrives.

## 1.9.194 [#19194]

* The quick check Pushary runs on read-only and MCP tool calls now keeps your refusal rules through a slow connection. When the policy request does not answer in time, the check uses the policy this machine cached in the last 12 hours, so a rule that refuses a tool still refuses it. Before, a session with no fresh copy of its own let the call run without checking those rules. This only ever adds a refusal; it never lets a call through that the check would have stopped.
* A policy request that fails in transit is now reported as a network failure instead of an unexpected error.

## 1.9.193 [#19193]

* `pushary setup` now finishes when your npm only installs releases older than its min-release-age, or published before a set date. Setup installs its own exact version globally, and npm refused that version as too new, so the agent step failed and setup told you to run another command. Setup now checks this before it changes anything, says which release your npm allows, and continues with that release and the same options. An install lock that an earlier failed run left behind is cleared first. Without such an npm rule nothing changes.

## 1.9.192 [#19192]

* A single-choice question with five or six options keeps its write-in on your phone. These questions do not fit the question card, so they go out as a plain list of options, and the list used to drop the Other box. On OpenCode every question takes a typed answer by default, so each of these questions lost it. Now the list asks your phone for an Other box whenever the question takes a typed answer, and your typed answer reaches the agent as your answer. A question that takes only its options still shows only its options. The Other box appears in the next Pushary phone app release and on the pushary.com decision page; until your phone app has it, the list looks as before.

## 1.9.191 [#19191]

Not published to npm. These changes first shipped in 1.9.192.

* `pushary doctor`: on a machine whose npm holds back new releases (`min-release-age` or `before` in your npm config), the "Global package up to date" check now passes when npm allows nothing newer than the release you have, and names the release that is waiting. Before, it failed and told you to run `pushary upgrade`, which then said there was nothing newer to install. When npm allows a newer release than yours, the check still fails, offers that release and names any newer one that is waiting. Doctor asks npm with the same `npm pack --global --dry-run` that `pushary upgrade` uses, only when a newer release is published, and gives npm at most 10 seconds in all. If npm takes longer, the check reports the published release as before.
* OpenCode 2: a question whose form has a field without a key reaches Pushary again. Your rules apply to it, so the kill switch or a standing deny dismisses it, and your phone is told to answer it in OpenCode. Since 1.9.180 such a question stayed in OpenCode with no rule and no notice.
* OpenCode, sessions started from your phone: when no OpenCode service was running and Pushary started one, your phone is told once, as soon as the service is up, even if the session then fails to start or you stop it. The notice says the service may not see API keys you export in your shell profile, that the OpenCode app and terminal will use it too, and that `opencode service restart` in a terminal starts it again with your shell's settings. A session that finds OpenCode already running sends nothing new.
* OpenCode question notices no longer repeat themselves. A question you need to answer in OpenCode reads "OpenCode is asking" with the question below it, and several read "3 questions. The first: ...". In updates-only mode the notice is titled "OpenCode has a question", or "OpenCode has 3 questions" for several, where it said "Agent has a question". A phone answer OpenCode did not take, for several questions, now reads "3 questions. The first: ... OpenCode did not take your answers from your phone."

## 1.9.190 [#19190]

Not published to npm. These changes first shipped in 1.9.192.

* Codex: when a rule lets a call run while it waits for your phone, for example "Allow Bash for this session" tapped on another card from the same burst, the Decisions page now lists that call as approved "By policy". Before, it listed only the withdrawn question as cancelled, with nothing saying the call then ran. The same entry appears when a rule covers a call that was still waiting for a free place. It names the tool and its target, not which rule. If the entry cannot be sent, the call still runs.

## 1.9.189 [#19189]

Not published to npm. These changes first shipped in 1.9.192.

* Cursor and VS Code gates (Cursor plugin 0.2.13, VS Code plugin 0.2.8, installed by `pushary setup`): when Pushary already has as many open questions in the session as it allows, the gate asks once instead of three times and does what the CLI hooks do. A shell command or MCP call in Cursor goes to Cursor's own prompt and the agent is told why; any call in VS Code goes to VS Code's own confirmation with the reason. A Cursor file edit, which has no prompt of its own, or a call under a rule that refuses when nobody answers, is refused, and the agent is told it did not run. Before, the gates asked three times and refused every call with "Pushary could not create a verifiable approval".

## 1.9.188 [#19188]

Not published to npm. These changes first shipped in 1.9.192.

* This CLI carries the OpenClaw plugin 0.1.8. A `write`, `edit` or `apply_patch` to a path with `#` in it, or a `%` that is not followed by two hex digits, such as `src/C#/Program.cs`, `notes#1.md` or `100%.md`, is now judged by where it lands, like any other path, so ordinary edits in a C# project run without asking. Before, every such path asked, and unanswered, it was blocked. OpenClaw reads `#` and `%` as ordinary characters in every path that is not a `file://` URL, and a URL still asks. Writes into OpenClaw's own files still ask with these characters in the path, such as `hooks/C#/handler.js` or `../C#/../openclaw.json`. A path with a percent escape such as `%2F` still asks, in case a later OpenClaw decodes it, and so does a path with `? * < > |`, a double quote or a control character. The preview sent to your phone now shows the change for these paths too, and a `.env` file is still left out.

## 1.9.187 [#19187]

* Codex, Always, with a rule that approves a call nobody answers: a burst of parallel calls larger than the eight questions a session can have open can now run the calls past the eighth, up to about 32 with a 30 second window. Before, those calls waited at most one phone window for a free place, gave up a few seconds before the first eight windows closed, and Codex was told they did not run. Now each one keeps waiting until a place frees, for as long as its own whole window still fits in the hook's time, about 130 seconds with a 30 second window. It then asks your phone, waits its window and runs as your rule says. If you change the rule to refuse or to wait while calls are still waiting for a place, those calls are refused rather than run under the old rule. A call that has already reached your phone keeps the rule it started with. A window above about 80 seconds leaves no room for this, and a rule that refuses or keeps waiting when nobody answers is unchanged.

## 1.9.186 [#19186]

* Setup no longer waits forever at the agent question. When nothing is typed there for 20 seconds, as happens when an agent runs setup in a terminal of its own, setup sets up the agents it detected, the same set pressing Enter would give, says so, and asks nothing more in that run. Each key you press restarts the 20 seconds. Pass `--agents` to choose without being asked.

## 1.9.185 [#19185]

* `pushary upgrade` now works when your npm holds back new releases (`min-release-age` or `before` in your npm config). It installs the newest release your npm allows, the same choice the daily automatic update makes, and names the newer release that is still waiting. Before, it tried the newest published release, npm refused it, and the command ended with "Upgrade failed: notarget No matching version found" and no next step.
* When your npm allows nothing newer than the release you have, the command installs nothing and exits without an error. It prints "Already on the newest version your npm allows", the release that is waiting, and to run `npx pushary@latest upgrade` again later. An earlier upgrade that was installed but not finished is still finished in that run.
* This matters most on Linux, where automatic updates are paused and `npx pushary@latest upgrade` is the way to update.
* To choose the release, `pushary upgrade` asks npm once which release it would pick for the `latest` tag, with `npm pack --global --dry-run`. It runs only when a newer release is published. With no release-age setting the command installs the same release as before.

## 1.9.184 [#19184]

* `pushary calls on`: when changing your number or turning calls on is refused because agent keys already made too many of those changes today, the CLI now says so and that you can make the change in the Pushary app or the dashboard. Before, it said you had used today's test calls.
* `pushary calls on` on a plan without phone calls now says "Phone calls need an active Agent, Agent Pro or Team plan.", as the phone app does. Before, it named only Agent and Agent Pro.

## 1.9.183 [#19183]

* A session in a git worktree you made yourself, or one a tool such as Conductor made, is named after the worktree's folder again, as before 1.9.173, so parallel worktrees of one repository can be told apart on your phone. Only Claude Code's own worktrees, in `.claude/worktrees`, keep the repository's name, such as the `bridge-cse_...` folders of sessions started from claude.ai.

## 1.9.182 [#19182]

* Claude Code plan approval: when the wait for your phone answer ends without one, for example after a dropped connection, a laptop that slept or a question that expired, Claude Code's plan dialog stays up for you to answer there. Before, the plan was declined as if you had stopped it. Only Approve or Keep planning from your phone answers the dialog now, and a Stop from your phone leaves it up too.

## 1.9.181 [#19181]

* `pushary clean` now removes only the line setup wrote to load your Pushary key file. Since 1.9.171 it also removed any other profile line of the same shape, `if [ -f FILE ]; then . FILE; fi`, which is how the Google Cloud SDK adds itself to your shell profile. If you use the Google Cloud SDK and ran `pushary clean` since 1.9.171, run its `install.sh` again to put those lines back.

## 1.9.180 [#19180]

* OpenCode 1: an answer you give on your phone to an OpenCode question is no longer lost when the request that hands it to OpenCode fails outright, for example on a dropped connection. Your phone now tells you to answer it in OpenCode, as it already did when OpenCode refused the answer. The answer is not sent again, because OpenCode may have taken it.
* The OpenCode plugin is now built from typed modules. Approvals, questions, sessions started from your phone and the kill switch work as before, and the plugin no longer throws on a few incomplete events. `pushary upgrade` rewrites the installed plugin. The plugin the Mac app installs changes with its next release.

## 1.9.179 [#19179]

* Codex, Always: a call nobody answers in the hook's time, about 170 seconds, no longer loses your answer. The question stays on your phone, and Codex is told the call did not run and to run the same call again.
* When Codex runs the same call again in the same turn, it joins that question: no second card and no second notification. An answer you gave in between applies once: yes runs it, no refuses it.
* The question is withdrawn as before when a rule now decides the call, the kill switch or a stop applies, phone approvals for the session are paused, it is a scope question, your rule refuses a call nobody answered, or the hook cannot record locally that it left the question open. A question left open is withdrawn when the turn ends or you type the next prompt, and if you had answered it by then you are told the call did not run.
* New fields the hook sends with the question: a sha256 fingerprint of the call (made from the Codex session id, turn id, working directory, subagent id, tool name and tool input), when its wait ends, and that Codex shows no prompt of its own if the call is refused. When its wait ends it sends Pushary the question id, the call id and the machine id.
* A call left waiting this way counts in the refusal report as unanswered.

## 1.9.178 [#19178]

* OpenCode can now be started from your phone. On a computer running `pushary daemon`, Fleet then New session offers OpenCode once OpenCode 2 or later is installed and setup has put the Pushary plugin in place. The session opens in OpenCode's own background service, the one the OpenCode desktop app and terminal share, so it shows in the desktop app as well. Approvals and questions reach your phone through the plugin as before, the session's replies appear in its transcript on the phone, a message sent from the phone becomes the next prompt, and Stop interrupts the turn. Write a model as provider/model, for example anthropic/claude-sonnet-4-5. OpenCode 1 is not offered, and a phone-started OpenCode session cannot be resumed from the phone yet.
* When no OpenCode service is running, the daemon starts one with OpenCode's own `service start`, using the desktop app's bundled CLI when it is installed, and never while another service is registered and answering. Pushary reads OpenCode's service registration only when the file belongs to you and nobody else can read it, talks to it only on this computer, and never writes its password anywhere.
* A computer with only OpenCode connected now counts as one that can start sessions from the phone: setup turns that on there unless you turned it off, as it does for Claude Code, Codex and Gemini, so run `npx pushary@latest setup` again on such a computer. `pushary doctor` says whether OpenCode can be started from your phone, and why not when it cannot.

## 1.9.177 [#19177]

* Codex: a call Pushary refuses without running it is now counted. When no question slot frees in time, when nobody answers within the time the hook can wait, when phone approvals for the session are paused, or when an Always question reaches no phone and comes back to the computer, the hook sends Pushary one report, with your Pushary key like every hook request. The report holds only these fields: that it is a refused call, the agent (Codex), the Codex session id, the tool name such as Bash, the reason, the delivery mode and how many whole seconds the hook waited. It never sends the command, the tool input, file paths, the repository, the branch or the machine id. The report waits at most 1 second and is not sent in the last second before Codex's hook time limit. Codex may get the refusal up to 1 second later while the report is sent, and a failed report is ignored, so the answer Codex gets is unchanged.

## 1.9.176 [#19176]

* Claude Code: a question Claude asks you now shows in Claude Code and on your phone at the same time, and the first answer counts. Before, Pushary held the question for up to 10 minutes while it asked your phone, so Claude Code showed "Asking 2 questions" with no way to answer it there, and only the phone could. This applies in default, plan, acceptEdits, bypassPermissions and auto mode, and in sessions started from claude.ai or the Claude app with `claude remote-control`. Answering in Claude Code, pressing Esc or closing the session takes the question off your phone. A question asked through the Mac app is still held until it is answered on the phone or the Mac notch.
* Answer on the phone and Claude Code closes its question with your answer. Answer in Claude Code and the question is withdrawn from your phone.
* Where the PermissionRequest hook is switched off, the call came from Cursor, the Mac app handed it down, or the mode is `dontAsk`, the question is still held and asked on the phone as before. Plan approvals (`ExitPlanMode`) are unchanged.

## 1.9.175 [#19175]

* Claude Code: approving a plan from your phone or the Mac notch now starts the work. Claude Code ignores an approval given before its plan tool runs, so it kept "Would you like to proceed?" open at the terminal, and a plan you had approved still waited for you at the keyboard. Pushary now asks about the plan when Claude Code shows that prompt, and answers it there. Approve starts coding in the mode the session had before planning. Keep planning keeps Claude planning and tells it to ask what to change. The plan is asked once, as before. If you answer the plan at the keyboard instead, the question is withdrawn from your phone. If Pushary cannot ask, Claude Code's prompt stays for you to answer. While the Pushary Mac app is running, this works without this update.

## 1.9.174 [#19174]

* Claude Code: a multiple-choice question that allows several picks, answered on your phone or the Mac notch, now reaches Claude as Claude Code writes it, such as `Pepperoni, Pineapple`, with a label that holds a comma or a quote in quotes, as Claude Code quotes it. It arrived as `["Pepperoni","Pineapple"]`, which Claude read as free text it should double-check rather than as your picks. Qoder, CodeBuddy and Droid questions take the same path and get the same format.

## 1.9.173 [#19173]

Not published to npm. These changes first shipped in 1.9.174.

* A session in a git worktree is named after its repository, not the worktree folder, in the questions, approvals and events the CLI sends, including the `claude` alias. Claude Code's `.claude/worktrees/<name>`, Conductor workspaces and Codex worktrees showed under the worktree's own folder name, such as `bridge-cse_01Frwpkm...`; they now show the repository's name, the same one a session in the main checkout shows, so two worktrees of one repository show the same name. Sessions whose hooks the Mac app runs, and the session list the Mac app reports, still use the folder name. A session in an ordinary checkout or a folder outside git keeps the name it had.

## 1.9.172 [#19172]

Not published to npm. These changes first shipped in 1.9.174.

* Setup asks which agents to set up when you run it at a terminal, also after you pair the phone app. Detected agents are pre-ticked, so pressing Enter sets up the same agents as before; untick one you do not want Pushary on. Before, a run that paired the phone set up every detected agent without asking and only printed "Selected automatically". A run with nobody at the terminal still selects the detected agents automatically: one whose input or output is not a terminal, such as setup an agent runs with its output sent to a file, and `--yes` or `--json`. `--agents` still names them exactly.

## 1.9.171 [#19171]

* Setup and `pushary login` no longer write your API key into your shell profile. The key goes in `~/.pushary/env`, readable only by you, next to `~/.pushary/config.json`. Your `~/.zshrc` or `~/.bash_profile` gets one line with no key in it, `if [ -f "$HOME/.pushary/env" ]; then . "$HOME/.pushary/env"; fi`, so new terminals still have `PUSHARY_API_KEY`. If your profile is a link into a dotfiles repository, that repository no longer receives a copy of the key.
* A key export an earlier version wrote into your profile is moved out the next time you run setup or `pushary login`: each such line becomes the loader above, in place, so an `if` block around it stays valid. The backup of the profile taken before that change is kept in `~/.pushary/backups`, readable only by you, and older `.pushary-backup-` copies of your profile that held a key, next to it or inside your dotfiles repository, are moved there too.
* `pushary sign-out` removes the key from `~/.pushary/env` too, and no longer leaves the key in a commented-out line in your profile. A line an earlier sign-out commented out is cleared the next time you sign in or run setup.
* `pushary clean` removes the loader line and `~/.pushary/env`, along with any key export an earlier version wrote. A key held in `~/.pushary/env` is revoked or spared by the same rule as one in your profile.
* `pushary upgrade` and the background update do not touch your profile, so an existing export stays until you next run setup or `pushary login`.

## 1.9.170 [#19170]

* `pushary sessions --json` prints your agent sessions and the questions waiting on them as one JSON object: each session's agent, status, machine, folder and subagents, whether it needs your approval, and each pending question with the session and machine it belongs to. It also prints this computer's machine id, so a script can pick out the sessions running here. It uses the key setup saved and reads the same session list the Mac notch shows. When Pushary cannot read your sessions, the command fails with an error instead of printing an empty list.

## 1.9.169 [#19169]

* This CLI carries the OpenClaw plugin 0.1.7, which closes three more gaps in its write guard. All three are in 0.1.6 and earlier.
* On macOS, a `write`, `edit` or `apply_patch` to a path under `/System/Volumes/Data`, `/.vol` or `/.nofollow` asks. Each reaches the same files as the ordinary path, but `realpath` does not resolve it, so `/System/Volumes/Data/Users/name/.openclaw/openclaw.json` overwrote OpenClaw's config without asking.
* A `sessions_spawn` with `project_id` or `project_git_url` asks, as `projectId` and `projectGitUrl` do. OpenClaw reads both spellings, and before, the snake\_case ones ran without asking.
* A `sessions_spawn` `cwd` that starts with `~\` is read as OpenClaw reads it on every platform, as a path next to the home folder. Before, with the gateway's working folder inside the workspace, it ran without asking.

## 1.9.168 [#19168]

* OpenCode on Windows: a question you answer, dismiss or interrupt in OpenCode is now withdrawn from your phone and the Mac notch, and so is one whose turn ends or whose plugin unloads while OpenCode keeps running. A question still open when you quit OpenCode on Windows may stay on the phone, as before. The plugin told the hook to withdraw it with a signal, and on Windows a signal ends the hook before it can cancel, so the question stayed on the phone with no deadline. Enough of them used up the 8 open questions a session may have and the 25 a workspace may have, and after that every question on the workspace was refused. The plugin now tells the hook by closing its input, which works on every system, and sends a signal only to a hook still running 69 seconds later. Before a question it asks the hook whether it understands this, and asks again when the hook's files change, so an upgrade or a downgrade under a running OpenCode is picked up. A hook from an earlier release, or one that gives no clear answer, is run exactly as before, and a hook that was too slow to answer or failed is asked again at the next question. A withdrawal that fails or runs out of time is now reported to Pushary instead of being dropped without a trace, for a question on every system and for a permission ask on macOS and Linux. On Windows a permission ask is still withdrawn with a signal, and an approval left on the phone waits out its 10-minute deadline. Setup and `pushary upgrade` write the new plugin.
* `pushary upgrade` no longer rewrites OpenCode's `AGENTS.md` instructions when it cannot rewrite the OpenCode plugin. The instructions tell OpenCode to ask with its own question tool, which reaches your phone only through the new plugin, so a failed plugin write now leaves both as they were, and the next upgrade tries again.

## 1.9.167 [#19167]

* Grok Build: its read-only tools no longer reach your phone. `grep`, `list_dir`, `glob`, `read_file`, `todo_write` and `search_tool` are now treated like Claude Code's reads: Pushary never asks about them, and a rule that denies one still blocks it without asking. Before, a rule that asked about every call sent each of them to your phone and held the call until you answered or the rule's timeout ran out. Shell commands, edits and MCP tools are asked as before.
* Grok Build: `read_file` works again. Pushary looked for the file in the wrong field of Grok's call, so it refused every Grok file read as a call it could not read. It now reads the file from `target_file` and the folder of a `list_dir` from `target_directory`, so a rule such as `Read(**/.env)` or `LS(/private/**)` blocks exactly what it names. A read whose file still cannot be read is refused, as before.
* Grok Build: write a rule for one of these tools with Claude Code's name for it: `Read`, `Grep`, `Glob`, `LS`, `TodoWrite` or `ToolSearch`. A rule saved under Grok's own name, such as `grep`, no longer matches.
* Grok Build's plan updates show in the session feed as "updated the plan" when Grok sends only the tasks that changed.

## 1.9.166 [#19166]

* This CLI carries the OpenClaw plugin 0.1.6, which closes three gaps in its write guard. All three are in 0.1.5 and 0.1.4 too.
* The write guard lands a relative path in the workspace as OpenClaw names it, as well as where its symbolic links lead. With `~/.openclaw/workspace` a link to a project folder, a `write` to `../openclaw.json` overwrote OpenClaw's config, and before it ran without asking.
* A `write`, `edit` or `apply_patch` of a file with more than one name, a hard link, asks, because a write changes the file under every name: a hard link in the workspace to `~/.openclaw/openclaw.json` or to a workspace hook changed that file, and before it ran without asking. Deleting a hard link, or moving one, asks as well, though OpenClaw only removes that one name. A hard-linked file elsewhere asks too, such as one pnpm or bun links into `node_modules` on Linux; on macOS they clone files instead.
* A `sessions_spawn` with a relative `cwd` is checked from the gateway's working folder, where OpenClaw resolves it, as well as from the workspace, and `~` is read with OpenClaw's home, which `OPENCLAW_HOME` can move, as well as the OS home. Before, `cwd: "sub"` was checked from the workspace and ran without asking, though OpenClaw starts that session in the gateway's working folder, which for the macOS service is `~/.openclaw` unless its working folder is set.

## 1.9.165 [#19165]

* This CLI carries the OpenClaw plugin 0.1.5, which closes `.env` leaks found in reviews of 0.1.4. The plugin now reads an `apply_patch` with OpenClaw's own grammar, so it accepts exactly the patches OpenClaw accepts and splits them into the same files. A header is trimmed, and counts only where the parser expects one: at the start of the patch, after a `*** Delete File:` line, after the `+` lines of an added file, and at a `***` line that starts a line inside an update. An indented header inside a `.env` update is therefore a line of that file. 0.1.4 started a new section there and sent the `.env` lines after it. The approval now names exactly the files OpenClaw writes, including one whose indented header follows a deletion or an added file, and withholds the lines of every `.env` hunk and of any hunk with a header-shaped line that names a `.env` file. A patch that moves a file into or out of a `.env` file withholds every hunk, because lines added to a file in one hunk travel with the move in the next. A patch that mentions `.env` and that OpenClaw would not parse is withheld whole, and names only the headers that start a line. A file name that matches a secret pattern, such as 40 or more letters, digits and slashes in a row, is still redacted like any other text.
* A complete `.env` write lists its names only when every name is uppercase letters, digits and underscores, and every value is unquoted, or quoted on one line with no backslash or inner quote. Otherwise it sends neither names nor values. Before, an escaped quote such as `MOTD="hello \"`, or a quote inside an unquoted value, made the next line read as a name, and a lowercase line such as a wrapped base64 tail was sent as a name.
* A file change the plugin cannot read withholds its parameters when its `path` is a `.env` file, or, without a `path`, when any parameter name or value mentions `.env`. That covers an `apply_patch` OpenClaw would not parse, such as `*** Add File:.env` without the space, an `apply_patch` whose patch is not a plain string, such as `command: ["apply_patch", "<patch>"]`, and a `write` or `edit` that passes `file_path`. A patch names the files whose headers start a line. Before, each of these sent every parameter, values included.
* A path is treated as a `.env` file when its Windows or POSIX reading resolves to one, such as `.env/x/..` or `.env/a\b/..`, with Windows trailing dots and spaces (`.env .`) and a trailing `</arg_value>>` removed. A path that is not plain is treated the same way: one with surrounding whitespace, a URL scheme in any case, a `:` anywhere but in a drive prefix such as `C:\` at the start, or any of `% ? # < > | * "` or an ASCII control character. OpenClaw resolves such a path differently in its default, workspace-only and sandbox setups, and in some it becomes a `.env` file: `FILE:///ws/.env?`, `.env</arg_value>>/` and `file:///tmp/x?/.env` all wrote one. Before, each of these sent the values. Ordinary paths, including Windows drive paths, spaces and non-ASCII names, are shown as before.
* The write guard asks for any path that is not plain, by the same rule: surrounding whitespace, a URL scheme in any case, a `:` anywhere but in a drive prefix, any of `% ? # < > | * "` or an ASCII control character. OpenClaw resolves such paths differently in its default, workspace-only and sandbox setups, and several reach its state: `FILE:///…/workspace/hooks/x.js`, `~/proj/.env</arg_value>>`, `.env<//arg_value>>`, ` /../../openclaw.json` and `file:///../hooks/x%5C.js` each wrote a protected file. Before, each ran without asking. A write through an ordinary `file://` URL now asks too. So does a `write` through a symbolic link whose target does not exist yet, because the write creates the target: a link committed to a repository, such as `docs/notes.md -> ../hooks/evil.js`, made a plain-looking write create `hooks/evil.js`, and before it ran without asking. On macOS and Windows the guard also folds names the way macOS does. It folds together the letters macOS treats as one, such as `ß` and `ss`, the long s `ſ` and `s`, a ligature such as `ﬆ` and `st`, and a final `ς` and `σ`, and keeps apart the ones macOS keeps apart, such as `‥`, fullwidth letters and the dotless `ı`. So `hookſ/x.js` asks like `hooks/x.js`. Before, macOS wrote such a path into the `hooks` folder without asking. When the path, or a folder the guard compares it with (OpenClaw's own folders, the home folder, the workspace or the gateway's working folder), has a character Node cannot fold the way macOS does, the write or session spawn asks: any character missing from Node's Unicode tables, such as an emoji newer than them, an unpaired surrogate, or two subscript iotas on one letter. In a sandbox, an absolute path inside the container, such as `/workspace/hooks/x.js`, is still not mapped to the host folder it writes, so it does not ask.
* The plugin decides from the path as written and does not follow symbolic or hard links, so a write through a link to a `.env` file is shown as a write to the link.

## 1.9.164 [#19164]

* On macOS and Linux, setup and `pushary upgrade`, and automatic updates on macOS, clear an install lock left marked "installation pending" once the process that started that installation has exited, the lock is more than an hour old, and the process list shows no npm install of Pushary still running. Before, nothing cleared it, so every setup, upgrade and daily update failed with "An earlier installation did not finish safely" until you deleted `~/.pushary/auto-update.lock` yourself. Pushary reads the process list with `ps` and keeps the lock while any npm `install` or `update` naming `pushary` or `@pushary/agent-hooks` is running, global or not, or a process runs from a dependency folder inside the installed package. The process doing the check and the shells that started it do not count, so `npm i -g pushary@latest && pushary setup` does not block its own setup. It also keeps the lock while the starting process is running, within the hour, for a lock dated in the future, and when `ps` cannot be read. Each refusal says which of these is holding it and how to retry sooner. The check reads command lines, so it still misses an installer that does not look like an npm install of Pushary, such as a renamed process, an install from a tarball path, or another package manager. On Windows the lock still stays until you remove it. This reverses part of 1.9.154 (#2828), which kept such a lock for good because elapsed time and an exited process do not prove npm stopped; the process list is the evidence Pushary now uses. A machine that 1.9.154 to 1.9.161 already left stuck clears the first time this release or a later one runs setup or upgrade there, for example `npx pushary@latest setup`; until then its daily update runs the older release and still fails.
* When npm's dry run before an install fails, from a dropped connection, a rejected token, a missing release or a timeout, Pushary reports npm's error and neither starts the install nor marks the lock. Before, it went on to the real install, which failed the same way and left the lock stuck. The dry run now gets the install's own time limit, 120 seconds, instead of 30, and an automatic update whose dry run fails records npm's error after that one dry run instead of trying a second. The install still goes ahead when the dry run could not start, or finished without naming a release.
* On npm 11.17.0, 11.18.0, 12.0.0 and 12.0.1, `npm pack` ignores `min-release-age-exclude` while `npm install -g` honors it. When that list names the package exactly, or as `@pushary/*` for `@pushary/agent-hooks` (a scope pattern does not cover the unscoped `pushary`), setup and `pushary upgrade` now install it instead of reporting a release-age refusal, and automatic updates install the newest published release instead of the newest one old enough for `min-release-age`. Pushary reads the list with `npm config get min-release-age-exclude --global`, only after npm held a release back.

## 1.9.163 [#19163]

* OpenCode: more of OpenCode's questions reach your phone. Before, only a single question with two to four options, a free answer or a yes/no did, and every other question stayed in OpenCode with nothing on your phone. Now a question with five or six options shows on the phone as a plain list to pick from, without the option descriptions or an Other box, and your pick fills in OpenCode's prompt. A call with two to four questions is asked on the phone one question at a time; once you have answered them all, the answers fill in OpenCode's prompt together, and answering in OpenCode first withdraws the question still open on the phone and asks no more. A question the phone still cannot show, such as one with a single option, seven or more options, or a multi-select with more than four, now sends one notification, `OpenCode is asking: ... Answer it in OpenCode.`, or `OpenCode is asking 3 questions, starting with: ... Answer them in OpenCode.` for a call with several. These questions follow the kill switch, a standing deny and Terminal mode like any other OpenCode question; before, the kill switch did not dismiss them.
* A question with five or six options to pick one from goes to the phone as the plain list when the rich question card cannot show it, instead of failing to reach the phone. Besides OpenCode, this covers Qoder, CodeBuddy and Droid when they send Claude Code's question format with more than four options. A multi-select with more than four options still does not reach the phone, as before. Claude Code and Codex questions, which have at most four options, are unchanged.

## 1.9.162 [#19162]

* Codex: a batch of parallel calls no longer gets calls turned away unasked. Codex can send many calls at once, and Pushary allows eight open questions per session. Before, every call past the eighth was refused at once, and Codex was told nobody was asked and the call did not run. Now such a call waits for a free place: 5 seconds after each refusal it checks your rules and asks again, for at most 30 seconds and at most one phone window, and only while a whole phone window still fits in the time Codex gives the hook. A place frees as soon as someone answers one of the open questions, or when one of them runs out of time. Once the call is asked, it follows your rule like any other question, including a rule that approves when nobody answers. If no place frees in time, the call is refused as before, and never approved.
* Codex: one tap can clear the rest of a burst. While a Codex call waits for your phone, Pushary checks your rules again, first after 4 seconds and then less often. If a rule now covers the call, for example after you tap "Allow Bash for this session" on another card from the same batch, the call runs and its question is withdrawn from your phone. An answer or a stop that arrives at the same moment wins, and a question that cannot be withdrawn refuses the call. If a deny rule or a Stop now applies, the call is refused and its question withdrawn. Risky commands, calls outside an agreed scope and calls no rule covers keep waiting as before. Only Codex `PreToolUse` changes; other agents and Codex's own confirmation are unchanged.

## 1.9.161 [#19161]

* `pushary calls`: set up phone calls from the terminal. `pushary calls on` asks for your mobile number and first name, places the test call, waits for you to confirm the number on it, asks you to agree to the calls, and turns them on. `pushary calls off` turns them off, and `pushary calls` shows whether they are on, the number they ring and the minutes left. `--number`, `--name` and `--yes` answer the questions for a terminal nobody is watching; without `--yes` there, nothing is changed. It uses the key setup saved, and whenever a key sets a new number your phone and email get a note saying which number calls now ring. Setup's list of useful commands now names it.

## 1.9.160 [#19160]

Not published to npm. These changes first shipped in 1.9.161.

* OpenCode: questions ask in OpenCode's own prompt again, and the same question also reaches your phone and the Mac notch. 1.9.156 sent every question through `ask_user`, which took away OpenCode's prompt, could not be interrupted from OpenCode while it waited, and gave the phone only the offered options. Now the plugin watches the form OpenCode's `question` tool raises, and only that form, and asks your phone without holding the prompt. Answer in either place and the first answer wins. The phone question stays open for as long as OpenCode's prompt does, so you can answer after an hour away; after the first ten minutes Pushary checks for your answer every thirty seconds. On the phone a choice shows each option's description and an Other box for a reply of your own when OpenCode takes a typed answer; a multi-select, a free answer and a yes/no work too. A phone answer replies to OpenCode's prompt through OpenCode's own reply route, so the model gets it exactly as if you had answered in the terminal. Pushary asks your phone only when it has checked that route first: on an OpenCode 2 server it cannot reply to, such as a standalone `opencode serve`, the question stays in OpenCode only. If OpenCode refuses the answer anyway, your phone is told to answer it in OpenCode; an answer that lost the race to one given in OpenCode sends nothing. When Pushary cannot confirm that route, it sends one notification, `OpenCode is asking: <question> Answer it in OpenCode.`, so you know to come back, and it follows the kill switch and Terminal mode as a question would. A Pushary outage or a question cancelled on the Pushary side leaves OpenCode's prompt open; only the kill switch or your own stop dismisses it. Answering, dismissing or interrupting in OpenCode, the turn ending or failing, OpenCode unloading the plugin and OpenCode exiting each withdraw the phone question. The kill switch dismisses the question and ends the step; Terminal mode leaves it in OpenCode; Notify-only sends a notification and leaves it in OpenCode; without a key nothing changes. A question call with several questions, a number field and an MCP server's question stay in OpenCode only, so the instructions now ask the model to put one question in each call. The `AGENTS.md` block tells OpenCode to ask with its own `question` tool and to use `ask_user` only when it has no question tool, naming `tools.pushary.ask_user(...)` inside `execute` for OpenCode 2 and `pushary_ask_user` for OpenCode 1. OpenCode 1 questions are answered on its `/question` route. A Mac app connection is unchanged: the Mac app's spec keeps the block that sends every question through `ask_user`, and its plugin leaves OpenCode's form alone, until the Mac app forwards the form.
* OpenCode 2: a deny from your phone or your Pushary rules now reaches the agent with its reason. Before, the plugin rejected the permission with no message, which OpenCode treats as a stop: it ended the step and rejected every other pending permission in the session. Now OpenCode hands the reason to the model as feedback and the model carries on with it, as Claude Code does after a deny. A kill from Pushary and an approval that was cancelled or became unavailable still reject with no message, so the step still ends, as Claude Code's turn does. An allow is still one approval. OpenCode 1 replies on its session route, which takes no message, so a deny there is unchanged.
* OpenCode 2: a turn that ends on an error is recorded in Activity as a failed turn and sends the same "OpenCode stopped on an error" push Claude Code's `StopFailure` sends, with OpenCode's own error message. The kill switch and Terminal mode keep it off your phone, and it is still recorded. An interrupted turn still sends nothing.
* OpenCode 2: a subagent's prompt, turn end and failure are no longer reported as yours. OpenCode runs each subagent in a child session, and Pushary recorded its prompt as a new prompt from you and its end as a finished turn. The plugin learns a session's parent from `session.created`, or asks OpenCode once per session and treats a lookup that takes over 2 seconds as no parent, and skips the prompt. A subagent's turn end or failure is recorded as a subagent stop on its own session under its parent, as Claude Code's `SubagentStop` is, so the subagent no longer looks busy for two minutes, and it sends no push. A subagent's tool calls are still recorded and its permission asks are still gated. When OpenCode cannot say whether a session has a parent, the report is sent as before.
* OpenCode: a shell command run in the project or in a folder inside it, whether OpenCode writes the working directory relative or absolute, now reaches your phone, judged in that folder: the phone shows it and a repository rule applies for the folder the command runs in, so a rule for a nested clone or submodule is not skipped. Before, any `workdir` not spelled exactly as the project path stayed in OpenCode's prompt. A working directory outside the project, or one starting with `~`, still stays there.
* OpenCode 2: when the event stream drops, the plugin subscribes again after 1, 2 and 5 seconds and then every 10 seconds until OpenCode unloads it. Before, one dropped stream stopped every approval until OpenCode restarted. A drop keeps what the plugin knows about running tool calls and pending asks, so a shell command outside the project still stays in OpenCode's prompt after the stream comes back, and an ask OpenCode repeats is answered once. It still prints one line, the first time. An approval asked while the stream is down stays in OpenCode's prompt.
* OpenCode 2: web searches, skills and subagents OpenCode asks about now reach your phone, as `WebSearch` with the query, `Skill` with the skill's name and `Task` with the subagent and its description, so rules for those tools apply, and a standing deny written for `Agent` refuses a subagent too. OpenCode asks about them only when your configuration says to. Questions, todos, `glob` and `grep` stay in OpenCode's prompt, so a broad ask rule does not push every search, and so do MCP tools: OpenCode names them `<server>_<tool>`, which nothing tells apart from a plugin's own tools or from Pushary's own `pushary_ask_user`.
* Setup and `pushary doctor` read OpenCode 2's `permissions` list after `tools` and `permission`, in the order OpenCode applies them, when they say which of `bash`, `edit` and `webfetch` OpenCode would run without asking. What setup writes is unchanged.
* Setup and `pushary upgrade` write the new plugin. An existing CLI connection gets it on the next upgrade, and a Mac app connection after the Mac app update and a reconnect.

## 1.9.159 [#19159]

Not published to npm. These changes first shipped in 1.9.161.

* Setup, `pushary upgrade` and automatic updates no longer leave the install lock stuck when npm holds back new releases (`min-release-age` or `before` in your npm config). Before installing, Pushary asks npm which release it would pick with `npm pack --global --dry-run`, which reads the same npm settings as a global install, runs no scripts and writes nothing. A release npm refuses is reported before the lock is marked, so the next run goes ahead with no file to delete. 1.9.154 had brought the stuck lock back: it kept the lock after any failed install, including a release-age refusal, so the next setup failed with "An earlier installation did not finish safely". A failed install that npm did start still keeps the lock, as in 1.9.154.
* Automatic updates install the newest release your npm allows instead of failing every day while the newest release is younger than your `min-release-age`. They never install an older release than the one you have. When nothing newer is allowed yet, the update is recorded as up to date with a note saying which release is waiting.
* When setup itself is too new for your npm, it tells you to run the newest release your npm allows, `npm exec --yes --package=pushary@latest -c "pushary setup --agents ..."`, instead of waiting until this exact release is old enough. Setups from 1.9.154 on refuse to replace a newer installed CLI; an older one that npm picks under a long `min-release-age` can still replace it.

## 1.9.158 [#19158]

* The CLI now tells Pushary why each tool call ran without a question, so a quiet session can be told apart from a broken one. This covers Claude Code and every agent that runs the same `pushary-hook` and `pushary-post-hook`: Qwen Code, CodeBuddy, Qoder, Droid, Devin, Antigravity CLI and Grok Build. `PreToolUse` leaves a small record for the call, keyed by its tool use id, saying how it ended: the agent's permission mode owned it, Claude Code's own allowlist owned it, a standing rule allowed it, Pushary asked, Pushary tried to ask and could not (for example because the workspace has no active subscription), the call went to the agent's prompt, Pushary could not decide, or it was refused or stopped. The `PostToolUse` report for the same call reads the record back and sends it as `gateOutcome`. Only calls whose `PostToolUse` Pushary reports leave a record: the gated tools, `Task` and `WebFetch`. `Agent`, `ExitPlanMode`, `AskUserQuestion` and MCP calls leave none, and a machine with no key leaves none. The record lives in your temporary folder for at most an hour, at most 512 at a time, in a folder only you can open. Expired records are cleared at most every 10 minutes, and a record that cannot be written is skipped without a message. What `PreToolUse` decides is unchanged.
* The tool, prompt, turn end, subagent, compaction, session start and end, notification, failed turn and auto mode denial reports now carry `permissionMode` when the hook input has one. Codex sends the same field on its tool, prompt, turn end, session and subagent reports, from the `permission_mode` its hook input already carries. Codex reports no `gateOutcome`.
* Both fields are additions to the existing reports, and the server accepts reports without them, so an older CLI keeps working against the new server and this CLI against an older one.

## 1.9.157 [#19157]

* This CLI carries the OpenClaw plugin 0.1.4. An approval for a `.env` file no longer sends its values. A complete write sends the variable names only when every line is a plain `NAME=value` assignment, a comment or blank. Any other line, such as a quoted value spread over several lines or an unclosed quote, means the approval sends neither names nor values. Before, a quoted value that spanned several lines had its later lines sent as written.
* An edit or a patch to a `.env` file sends the paths and leaves out the changed lines, because a fragment can start inside a value. A patch that also changes other files still shows those files in full, including when its file headers are indented. A patch that arrives in `command`, as OpenClaw's Codex harness sends it, is shown as a patch with the same rules. Before, it was shown as a command with the whole patch, `.env` lines included.
* A `write` or `edit` to a `.env` file whose parameters the plugin cannot read, such as an `edits` entry without its `newText`, sends only the path instead of every parameter. An `edit` that also carries a `command` parameter is shown as the file change, not as a command.
* The plugin recognises Windows paths, `file://` URLs (including a network share such as `file://server/share/.env`) and Windows stream names such as `.env::$DATA` as `.env` files.

## 1.9.156 [#19156]

* OpenCode: questions reach your phone. OpenCode asked its own questions, such as "ask me a multiple choice question", with its built-in `question` tool, which shows only in the terminal. Pushary forwards OpenCode's permission prompts, but no plugin API can answer that tool, so nothing reached the phone or the Mac notch. The instructions setup writes to OpenCode's `AGENTS.md` now tell it to ask every question through Pushary's `ask_user`, one at a time, even while you are at the terminal, as fx already does. They name both forms OpenCode offers: `tools.pushary.ask_user(...)` inside `execute` when OpenCode 2 lists Pushary under Code Mode, and the direct `pushary_ask_user` otherwise. So a question now reaches your phone and the Mac notch while you are at your desk too, and you can answer it there. In Terminal mode Pushary hands it straight back to OpenCode's prompt. A handoff that asks in the terminal, or an `ask_user` that fails, still falls back to OpenCode's own prompt. Setup and `pushary upgrade` write the new block; an existing CLI connection gets it on the next upgrade, and a Mac app connection after the Mac app update and a reconnect.

## 1.9.155 [#19155]

* Antigravity CLI: `run_workflow` now goes to your Pushary policy before it runs. agy 1.5.9 added the tool for everyone. The agent writes a Python script, agy runs it in its own Python, and the script can run commands and write files with no further hook call. Setup sets `toolPermission` to `always-proceed` so that Pushary is agy's only gate, yet the hook matcher left `run_workflow` out and the hook had no rule for it, so a workflow script ran with nobody asked. The script is now judged as `python3 -c '<script>'` under your `Bash` rules, and your phone shows it in that form. It gets the answer the same code would get from `run_command`: under the default rules your phone is asked. A `Bash` rule whose pattern covers `python3 -c`, such as `Bash`, `Bash(python3:*)`, `Bash(python:*)` or `Bash(python3 -c:*)`, or a preset that lets shell commands run, lets it run unasked. The shell read-only check and rules for other commands, such as `Bash(git:*)`, never clear it. A call with a missing or blank script is blocked. A finished workflow is not recorded in Activity: `PostToolUse` does not match `run_workflow`, as for `manage_task`. Setup, `pushary upgrade` and the Mac app's spec write the new matcher. An existing CLI connection gets it on the next upgrade, and a Mac app connection after the Mac app update and a reconnect.

## 1.9.154 [#19154]

* Setup and upgrade keep the install lock after an interrupted or failed npm install. A dead wrapper, an old timestamp, or an npm error message no longer permits another installer to race a surviving npm process. Recovery explains how to verify that the install has stopped before removing its marker.
* Setup recovery commands use the exact running release and preserve your npm release-age policy. An unknown version or an older setup cannot replace a newer global CLI. Manual upgrades install the exact release they checked.
* Setup, npm and OpenClaw failure messages redact credentials before printing them, including JSON output.

## 1.9.152 [#19152]

* A tool counts as one of Pushary's own only when it comes from the server named exactly `pushary`, the claude.ai Pushary connector or the Pushary plugin, followed by one tool name. Before, any tool whose name started with `mcp__pushary__` counted. Claude Code writes every character a server name may not carry as `_`, so a different server named `pushary__fs` or `pushary.` lists its tools as `mcp__pushary__fs__write_file` or `mcp__pushary___run_shell`. In Claude Code, 1.9.150's `PermissionRequest` hook allowed every such tool without a prompt, and `PreToolUse` skipped the kill switch and standing denies for them. The Codex hooks skipped them the same way, and `pushary claude` allowed them while your phone drives the session. They are now judged like any other MCP tool. Pushary's own tools, the connector's and the plugin's are left alone as before.

## 1.9.151 [#19151]

* This CLI carries the OpenClaw plugin 0.1.3. An `exec` approval now shows the environment the call sets and every other parameter, such as `host`, `node`, `security` and `ask`, before the command, and the question names the environment variables. Before, it showed only the command, so a `git status` with `GIT_CONFIG_*` variables could run another command after one yes. Values named like a credential are redacted.
* The plugin asks before a `write`, `edit` or `apply_patch` into the workspace `.openclaw` folder, for every spelling of the path. OpenClaw loads plugins from `<workspace>/.openclaw/extensions` before the installed ones, so an agent could otherwise put its own plugin with the id `pushary` there and switch off the gate at the next gateway start.
* The plugin asks before every `sessions_spawn` with `runtime: "acp"`, whose harness runs its own tools where the plugin cannot see them, and before every `nodes` action except its reads, including `run` on a paired machine and `approve` for a new one.
* The plugin 0.1.2 changes reach setup too. A gated call longer than 4,000 characters once secrets are redacted is blocked instead of being asked about in part. A file change shows the path and the lines it removes and adds. A `.env` file's values are never sent. Hidden characters are shown as codes.
* `pushary upgrade` tries the OpenClaw plugin reinstall again when OpenClaw refused it the last time. Before, it recorded the new copy as installed before OpenClaw accepted it, so a refused reinstall kept the older plugin until a later CLI carried another one.
* The editor plugins this CLI carries no longer include their test files.

## 1.9.150 [#19150]

* Claude Code: the `PermissionRequest` hook allows Pushary's own tools, under `mcp__pushary__`, the claude.ai Pushary connector (`mcp__claude_ai_Pushary__`) and the Pushary plugin (`mcp__plugin_pushary_pushary__`), without a key and without asking pushary.com. Before, it left `mcp__pushary__` to Claude Code's own prompt and judged the other two like any tool. Claude Code adds your claude.ai connectors to every session, so with this CLI's hooks installed and the connector enabled, its prompt for the connector's `ask_user` could push an approval for Pushary's own question to your phone, and a standing `*` deny refused it. A plugin user, who has no allow rule from setup, would have had the prompt for the agent's own question wait in the terminal while they were away. The `PermissionDenied` hook leaves all three alone. `PreToolUse` is unchanged.
* Setup and `pushary upgrade` add `mcp__claude_ai_Pushary__*` and `mcp__plugin_pushary_pushary__*` to Claude Code's allowed tools beside `mcp__pushary__*`, so Claude Code does not ask before it calls Pushary under those names either. `pushary clean` and disconnect remove them, and keep a narrower rule of your own such as `mcp__claude_ai_Pushary__ask_user`. Other agents get only `mcp__pushary__*`, as before.
* Claude Code: an approval route that names one of Pushary's own tools on the claude.ai connector or the plugin exactly, such as `mcp__plugin_pushary_pushary__send_notification`, no longer holds that call in auto mode. Before, `PreToolUse` held it for someone else's answer, and when nobody answered it went back to the terminal prompt. A route that names any other MCP tool holds it as before.
* Claude Code: the `PreToolUse` entry setup and `pushary upgrade` write for `WebFetch`, `Task` and `Agent` has a 30 second timeout instead of 600. That entry applies only the kill switch and standing denies and never waits for an answer, so a hook that hangs can no longer hold those calls for up to 10 minutes. 30 seconds still covers the Claude Code plugin's cold `npx` start, about 8 seconds, plus the check itself. The `mcp__.*` entry keeps 600 seconds, because an approval route can hold an MCP call. The Mac app's spec and the Claude Code plugin carry the same timeout.

## 1.9.149 [#19149]

* Codex and Gemini sessions started from your phone now check the keys they encrypt transcripts for against the keys this computer already trusts, as every other transcript upload does. Before, they encrypted for whatever keys the server returned. Now, if those keys change, these sessions upload nothing, print the same "Transcript sync stopped" message with the `pushary transcripts trust` step, and resume once the keys match again.

## 1.9.148 [#19148]

* Setup no longer prints your API key. If your shell profile already sets `PUSHARY_API_KEY` in a line Pushary did not write, setup used to print `export PUSHARY_API_KEY='<your full key>'` for you to paste. Now it says where the key is saved and tells you to delete that line or set it to the same key.
* If your npm only installs releases older than a set age (`min-release-age` or `before`), setup no longer fails with a bare "notarget" error. It says why and prints one command to run instead: `npm exec --yes --package=pushary@latest -c "pushary setup --agents <agents>"` (`npm.cmd` on Windows). npm then picks a release your setting allows. Setup still installs exactly the release that runs it.
* A failed install no longer blocks every later setup, upgrade and auto-update. When npm stopped because the version was not found (ETARGET or E404), it wrote nothing, so the install lock is now released. A lock left by an install whose process died more than 15 minutes ago is now cleared on the next run. Before, both stayed until you deleted `~/.pushary/auto-update.lock` by hand.
* When setup set up no agent, it now says "No agent was set up. Your key is saved.", says when push works, and gives a doctor command that runs without a global install. It used to say "Nothing was configured" even when your key was saved and a test notification arrived.
* The transcript notice now reads: "Your phone can decrypt them. Pushary can open a session only for a documented legal request, and every opening is logged."

## 1.9.147 [#19147]

* `pushary setup` can connect OpenClaw. Pick OpenClaw, or pass `--agents openclaw`. This CLI carries the Pushary plugin for OpenClaw: setup writes it to `~/.pushary/openclaw-plugin` and runs `openclaw plugins install ~/.pushary/openclaw-plugin --force --accept-capabilities` and `openclaw plugins enable pushary`. Nothing is fetched from npm. `pushary upgrade` reinstalls the plugin when this CLI carries a newer copy, and keeps it disabled if you disabled it.
* The plugin gates every `exec` call, the `process` actions that type into a running session (`write`, `send-keys`, `submit`, `paste`), and the `plugins`, `gateway` and `openclaw` actions that install, disable, reconfigure, update or restart OpenClaw, every `automations` and `terminal` action except their reads, and any `write`, `edit` or `apply_patch` into OpenClaw's own state, `~/.config/openclaw`, `~/.pushary` or its gateway service files, outside the agent's own workspace. These are the tools OpenClaw gives the agent to turn the plugin off; the plugin README lists what the gate does not cover. A `sessions_spawn` into a folder outside the agent's workspace asks too. Writes anywhere else run without asking. The plugin only talks to `https://pushary.com` and `https://www.pushary.com`. It does this through OpenClaw's `before_tool_call` hook and asks you in Pushary. A call runs only on the answer yes, and a stop from Pushary wins over any answer; anything else, no answer within about five minutes, a cancelled call or an unreachable server blocks it. `plugins.entries.pushary.config.gatedTools` adds more tools. It needs OpenClaw 2026.11.3 or later. Phone calls are not offered for OpenClaw yet.
* Setup stops without changing anything when OpenClaw will not report its plugins, or when another package already uses the plugin id `pushary`. It acts on the OpenClaw your current shell points at, and keeps one record per OpenClaw state directory of what `plugins.entries.pushary` was before it ran, so clean can undo each install.
* `pushary doctor` reports whether the plugin is installed, enabled and registers its gate, and whether it can read your key, including a key in the gateway's `.env` file. `pushary clean` uninstalls the plugin and puts back the settings you had before setup. When the plugin cannot be removed, clean keeps and does not revoke your key, so the plugin is never left blocking every call.
* Setup finds OpenClaw from `openclaw` on PATH, `~/.openclaw/bin/openclaw` or `~/.local/bin/openclaw`, and its state directory as OpenClaw resolves it (`OPENCLAW_HOME`, `OPENCLAW_STATE_DIR`, `OPENCLAW_CONFIG_PATH`). Clean and upgrade run each recorded OpenClaw with the variables setup recorded for it.

## 1.9.146 [#19146]

Not published to npm. These changes first shipped in 1.9.147.

* Setup no longer sends you to the browser push page by default. When nothing of yours can receive an approval and setup did not pair a phone in this run, for example because it reused a saved key or you passed `--key`, it shows a QR code and the link for the Pushary app ([https://pushary.com/download](https://pushary.com/download)) and tells you to sign in with the same account and allow notifications. Before, it printed your site's subscribe page first and the app second. The subscribe page now appears only when you ask for it with `--connect web` or `--connect browser`.
* `pushary pair` pairs the Pushary app by default. If an app of yours is already connected it sends a test notification; otherwise it shows the pairing QR, the [https://pushary.com/pair](https://pushary.com/pair) link and the fingerprint, waits for your phone to approve, as setup does, and then checks that the phone registered for notifications. This computer keeps the key it has: the key the pairing makes is revoked as soon as the phone approves. A phone that approved for another workspace, for another account, or as a teammate on this computer's own site is not tested; the command says which it is and how to fix it. The phone's approval screen names the agents found on this computer. Off a terminal, the first line says the command keeps running until the phone approves, for up to 15 minutes, so an agent should run it in the background. In CI it draws no QR, says which variable made it CI, and only checks what already reaches you, so a browser channel of yours still gets its test notification and exit 0. Browser web push now needs `--browser`; before, bare `pushary pair` opened your site's subscribe page. `--app` still works and means the same as no flag. When the phone approved but has not allowed notifications, it says to allow them and run `pushary doctor --roundtrip`, not to pair again, and each fix is printed once.
* `pushary status`, `pushary doctor` and setup's delivery check give the same advice when no phone of yours is connected: get the app at [https://pushary.com/download](https://pushary.com/download) and sign in with the same account. They used to say `pushary pair`, which opened the browser page. The hints that sent a computer with a key to `setup --connect app`, which makes a new key and switches the computer to it, now name `pushary pair`, which keeps the key: setup's closing lines, `pushary pair` itself, and the Pushary skill (0.13.4).
* Setup and `pushary pair` decide they are in CI from variables only a CI runner sets: `CI`, `GITHUB_ACTIONS`, `GITLAB_CI`, `CIRCLECI`, `TRAVIS`, `TF_BUILD`, `BUILDKITE_BUILD_ID`, `CODEBUILD_BUILD_ID` or `CODEBUILD_BUILD_ARN`, `TEAMCITY_BUILD_PROPERTIES_FILE`, and for Jenkins `JENKINS_HOME` with `EXECUTOR_NUMBER` or a `BUILD_TAG` that starts with `jenkins-`. Setup used to look at `CI` alone, so Azure Pipelines, CodeBuild and Jenkins runs without it waited for a QR nobody could scan. A variable people export by hand, such as `JENKINS_URL` for the Jenkins CLI, does not count, so a laptop with it in the shell still pairs. When setup refuses to pair in CI it names the variable, for example "No API key, and setup does not pair in CI (JENKINS\_HOME is set)."
* Setup run by an agent, with its output going to a log instead of a terminal, now confirms a pairing the same way a terminal run does. After the app approves, it waits up to 45 seconds for the phone to register for notifications and then sends the test notification. Before, it skipped that wait, printed the browser push link and could exit 6 with "Phone delivery is unverified" for a phone that was seconds from registering. When the phone still has not allowed notifications, the closing lines say to allow them and run `pushary doctor --roundtrip`, not to pair again.
* When setup is stopped with SIGTERM while it waits for your phone, which is usually an agent's command timing out, it says it was stopped before your phone approved and the pairing code was cancelled, and that the command has to keep running in the background until the phone approves. `pushary pair` says the same. It used to say "No app yet?", which named the wrong cause. Ctrl-C keeps its wording. A signal now always wins: setup and `pushary pair` exit 143 or 130 with the stop message only, even when the cancel request to pushary.com is slow, instead of sometimes printing a second way out and exiting 3 or 6. Messages after a failed pairing name the command you ran, `setup` or `pushary pair`.

## 1.9.145 [#19145]

* Hermes: Hermes skips its own dangerous-command approvals when its terminal backend is a container: `docker` with no host folder mounted, `modal`, `daytona`, `vercel_sandbox`, or a plugin backend that marks itself as a sandbox. Pushary gets those approvals through Hermes, so on such a backend no shell command reached your phone, and nothing said so. `pushary doctor` now names the backend, says that Pushary only gates the tools listed in `PUSHARY_GATE_TOOLS` there, and gives the fix.
* Setup run at a terminal without `--agents` offers to add `terminal` to `PUSHARY_GATE_TOOLS` on such a backend, so your phone is asked before each shell command, read-only ones included. The answer defaults to No. With `--agents`, or without a person at the terminal, it changes nothing and prints the command instead. `--hermes-gate-terminal` makes the same change without asking. Setup writes the setting with `hermes config set`, which saves it in `~/.hermes/.env`, keeps any tools already listed, and records what was there before so `pushary clean` puts it back. On a backend where Hermes checks commands itself, the flag leaves the setting alone.
* Doctor reads `TERMINAL_DOCKER_VOLUMES` and `TERMINAL_DOCKER_MOUNT_CWD_TO_WORKSPACE` from Hermes too, so a host folder mounted only in `~/.hermes/.env` no longer reads as a container that skips approvals. With Pushary as the approval transport, doctor warns when `command_allowlist` holds `plugin_rule:terminal`, which **Always allow** adds and which lets every shell command through, instead of saying Pushary gates them. Doctor and setup read these settings as a gateway running as a service sees them, so a `PUSHARY_GATE_TOOLS` exported only in your shell no longer reads as gated.
* The Hermes plugin Pushary installs is now 1.0.2. When Hermes loads it on such a backend and `PUSHARY_GATE_TOOLS` does not name `terminal`, it logs one warning with the command that fixes it.

## 1.9.144 [#19144]

* The Pushary instructions this CLI writes into AGENTS.md and GEMINI.md, and the Pushary skill it installs (0.13.3), say what to do when you ask an agent to call, phone or ring you if it gets stuck: ask with `ask_user`. Pushary may phone you only when the `ask_user` reply includes `phoneCall`; without it no call is planned, and the agent is told not to promise one. While the reply is pending and has no `handoffAction`, the agent keeps waiting with `wait_for_answer`; with one, it follows the handoff.
* The skill's description is cut to 1015 characters, inside the 1024 that Agent Skills and Codex read. It no longer names "keep working while I am in a meeting" or the Claude Max line.
* fx: the instructions setup writes into `~/.fx/AGENTS.md` say how to load a Pushary tool both in an fx with the `toolbox` tool, which replaces `mcp_select_tool` in fx after 0.0.16, and in an older fx. Setup and `pushary upgrade` say fx picks up the change automatically and to restart it if Pushary's tools do not appear, since fx 0.0.15 removed `/mcp reload`.

## 1.9.143 [#19143]

* A hook waiting on your answer no longer cancels the question when one poll fails. A network blip, a dropped connection, a server error or a rate limit while the hook waits for `wait_for_answer` used to withdraw the question at once, so a phone call or a late tap had nothing left to answer. The hook now keeps polling with growing pauses (2, 4, 8, then 15 seconds) until its own deadline. A failure that will not pass, such as a refused request, a tool error or a reply the hook cannot read, still withdraws the question right away. The `pushary claude` wrapper waits the same way, and a session cancelled during a pause stops at once.
* A wait that saw a failed poll ends as a stop, as a failed poll did before, never as a timeout, even when the server is back before the deadline. A timeout rule that approves cannot fire because the network was down.

## 1.9.142 [#19142]

* Keep a routed approval waiting long enough for the selected teammate's phone call, even when the requester has calls disabled. The extra wait applies only to matching human-approval routes; kill, deny, automatic decisions and native handoffs keep their precedence.

## 1.9.141 [#19141]

* A deny, ask or route rule on a command covers it again when a script handed to a shell runs it. 1.9.140 changed how those scripts are found and let some through. With `Bash(git push:*)` set to deny beside a broad allow, a push was allowed when it sat in a `bash -c "..."` script that had a `)` earlier in it and an apostrophe in a comment, when `find -exec` ran that shell, when a leading input redirection such as `< /dev/null` came before it, and in `echo "$(2> err.log git push origin main)"`. Each of these is refused again, and an ask rule or an approval route on the command applies as before.
* How: the way 1.9.139 found scripts is back beside the way 1.9.140 finds them, and a command with a quoted `>` in it is judged twice, once reading that arrow as text as 1.9.140 does and once reading it as a redirection as 1.9.139 did. The strictest answer wins, and an approval route that only one of the two readings finds applies, also when the server works out the route for Codex, Gemini, OpenCode or a Partner ask. Nothing 1.9.140 reads is changed, so what it got right is kept: a quoted arrow that is only text, as in `echo "=> pushing" && git push origin main` after a heredoc with an apostrophe in it, or `x=$(echo "a > b"; git push origin main)`, does not hide the command after it. 1.9.139 allowed both. A push that an approval route holds for someone else keeps that hold when other text in the same command meets a different ask rule only through one of these extra readings. The check takes as long as it did on 1.9.139 for a command that names scripts for a shell, and about as long as 1.9.139 and 1.9.140 together when it is judged twice.
* One difference from 1.9.139 stays in which route is used. When the two readings find different routes, the one held for someone else wins, and otherwise the one found by reading the arrow as 1.9.140 does. With a route on `Bash(docker:*)` and a route on `Bash(git push:*)`, `docker ps; echo "$(2> err.log git push origin main)"` goes to the docker route's approver. 1.9.139 sent it to the push route's. The question it gets is the stricter rule's, and when the docker and push rules are equally strict, the docker rule's.
* One thing 1.9.140 fixed is undone: text a command only prints is read as a script again when it names a shell and has a `#` in it, such as `echo bash -c 'git push origin main # later'`, and can be refused by a deny rule on the command it mentions. That was the behaviour up to 1.9.139.
* Still not read, as in every version so far: a command behind `ssh host`, `setsid` and other wrappers Pushary does not see through; a script without a comment inside double quotes that also holds a `(` or `)`, as in `x=$(bash -c "if (true); then git push origin main; fi")`; the commands after the first one in a double-quoted substitution, as in `OUT="$(cd /repo && git push origin main 2>&1)"`; and the extra readings for a command longer than 16 KB.
* Phone start: when a launch request reaches this computer a second time and the first attempt cannot be confirmed, the daemon still refuses to start a second session, and it now reports the failure as one that may be retried. 1.9.140 reported it as final, which also happened when the first delivery was lost and nothing had started. The next phone app build offers Start again for it.

## 1.9.140 [#19140]

* After a successful setup on Agent or Agent Pro, the Teams link opens the same page with a campaign tag so we can measure visits from the CLI.

Also shipped in 1.9.140 and not listed when it was published:

* Codex: when Codex asks for a permission profile (network access, folders it may read or write), the request goes to your phone. You can allow it for the turn, allow it for the session, or deny it. A standing deny, a scope contract and an approval route still apply. Before, Codex got an error and nobody was asked.
* Codex: a request the bridge does not support gets an error reply. Before, the bridge answered with a decline, which was not always one of the choices Codex offered.
* Codex desktop: a phone answer that arrives after the relay has closed is no longer passed on.
* Phone start: a launch keeps one id from the phone through retries, so a lost response does not start a second session. A request delivered twice to this computer is not launched twice.
* Phone start: this computer reports which agents it can start from one shared list, the same one the phone and the server read.
* The reading of nested shell scripts changed. See 1.9.141 for what that broke and how it was put back.

## 1.9.139 [#19139]

* A folder rule no longer covers a path that uses `..` to leave the folder. With `Write(/Users/you/**)` set to approve, a write to `/Users/you/../outside.txt` was allowed without anyone being asked, because the rule was checked against the path as written. Rules now see the path with its `.` and `..` worked out from the text, against the working folder when the path is relative: that write is asked about, and a deny on a folder, such as `Write(/etc/**)`, now catches `/repo/../etc/passwd`. Symbolic links are not followed. A path whose place cannot be worked out, such as `../notes.txt` with no working folder or `~/../x`, is never covered by an approve rule that names a path; a deny still applies to it. A path longer than 4,096 characters is never covered by such an approve rule either. Paths without `.` or `..` match as before. A scope contract judges paths the same way, and a workflow file reached through `..`, such as `.github/x/../workflows/ci.yml`, now counts as a workflow file. The server applies this to approval routes and to the gate the Mac app and the editor plugins use once the dashboard is deployed.

## 1.9.138 [#19138]

* Windows: the background daemon runs without a console window. Before, a `node.exe` window opened at every logon and stayed open, and closing it stopped phone-start until the next logon. The window now appears only for the moment it takes to start a hidden supervisor, and the daemon's output goes to `daemon.log` and `daemon-error.log` in `~/.pushary`, as on macOS. The next setup or `pushary upgrade`, including an automatic one, ends the old task and its window and replaces it.
* Windows: End in Task Scheduler no longer stops the daemon; use `pushary daemon stop`. `pushary daemon start`, or Run in Task Scheduler, on a daemon that is already running now restarts it.

## 1.9.137 [#19137]

* After `npm uninstall -g pushary`, the background service stops trying to start the removed program. Before, macOS and Linux restarted it every 10 seconds for good, writing an error each time.
  * macOS: the service exits cleanly when it starts and Pushary is gone, so launchd does not restart it.
  * Linux: systemd skips the start when the program is gone, at login and on its automatic restarts. systemd 253 and older check the start condition again on each restart; 254 and newer run the unit's new condition command, which versions before 243 ignore with a warning.
  * Linux: that condition command runs with the service's Node, so a Node that cannot run also skips the start instead of failing it, for example after nvm or asdf removed that version. `pushary doctor` reports a Node that is gone and says to run `pushary daemon install`; it does not catch a Node that is there but broken.
* Nothing is deleted. Reinstalling Pushary does not start the daemon by itself: it starts at your next login or agent session, or when you run `pushary setup` or `pushary upgrade`. The same now holds if the daemon restarts in the moment `npm install -g` is replacing its files, or at a login where the program's disk is not mounted yet: it stays down until then, where before it came back 10 seconds later.
* A service you already have gets this the next time setup, `pushary upgrade` or `pushary daemon install` rewrites it. On Linux automatic updates are paused, so run `pushary upgrade` there.
* `pushary doctor` fails a row when the background service starts a Pushary install that is gone.
* Windows did not loop and is unchanged. A supervisor still running when the package is removed restarts a crashed daemon, with backoff, until you log off.

## 1.9.136 [#19136]

* Qwen Code: tapping yes on your phone lets the command run. Before, Qwen read Pushary's yes as "carry on to the usual prompt", so the command still waited at Qwen's own approval prompt in the terminal while your phone showed the question as answered. A call Pushary already allows, such as a read-only command or an auto-approve rule from the dashboard, now runs at that prompt too. CodeBuddy and Qoder already ran the call on a yes and are unchanged.
* A file edit from Qwen Code, Antigravity or another agent wired through a hook profile is refused when it names two different files under two path keys, since Pushary cannot tell which one the agent writes. Before, Pushary judged the first key it knew while the agent could write the other.
* Codex: the decisions Pushary passes from one Codex hook to the next are now kept in a temp folder only you can open. If that folder is open to other users, Pushary prints one line and asks again at the next step instead of reading it.

## 1.9.135 [#19135]

* A phone instruction whose receipt the server refuses for good, because the server no longer has a record of it, it was settled another way or it belongs to another session, is no longer sent again every few seconds. Before, the background daemon sent the same receipt every 3 seconds for up to a week, a hook kept the instruction waiting so the session took no new message from your phone, and `pushary claude`, Codex and Gemini sessions started from your phone stopped taking new messages once 32 such receipts had piled up. Now each Pushary process tries a refused receipt once and does not show that instruction to the agent if the server offers it again. The daemon, hooks and `pushary claude` say so once in their log (a hook writes it to its stderr); a refusal of the receipt sent as delivery starts is remembered without a log line. A Pushary process started before this update, such as a `pushary claude` session left running, keeps sending it until that process restarts. A receipt that could not reach the server, or that hit a sign-in or rate limit, is still sent again. One limit remains: when the server has lost the instruction but still holds its claim on it, that instruction does not reach the agent, as before, and the session's next phone instruction can wait up to an hour.

## 1.9.134 [#19134]

* Linux: on a machine you reach over SSH, phone-start keeps running after you log out, and starts again after a reboot. Setup, `pushary upgrade` and `pushary daemon install` now turn on systemd lingering for your user unless you are signed in to a desktop session there, and say so. Where the system refuses, they print the `sudo loginctl enable-linger` command instead. Before, systemd stopped the daemon when your last SSH session closed, while setup still reported phone-start as working. `pushary doctor` has a new row, "Remote-control service survives logout".

## 1.9.133 [#19133]

* The background daemon starts again by itself after its lock file was left empty or cut off, for example when the disk filled up or the computer lost power while it was starting, and, on macOS and Linux, after a power cut or forced restart left a lock that names a process number another program now uses. Before, it exited at once and was restarted again and again, writing an error each time, and even `pushary daemon restart` could not clear the second case.
* Linux: setup, `pushary upgrade` and `pushary daemon install` can replace a daemon that systemd keeps restarting after a crash. Before, they stopped with "Could not inspect whether the native service is running: activating" and left the crash loop in place.

## 1.9.132 [#19132]

* Windows: your phone shows Claude's reply as it streams, as it does on macOS and Linux. Before, a file check that only fits macOS and Linux refused the live preview on Windows, so the phone showed only the finished reply.
* Windows: setup and `pushary upgrade` can ask an npm-installed Codex to confirm Pushary's hooks are trusted, and a phone-started Codex session starts when Codex was installed some other way. Before, Windows listed the extensionless npm file first, which cannot be started, so the check failed with `ENOENT`.
* Windows: Pushary's background checks, npm calls, the one-time phone-control install, automatic updates and a phone-started Codex session no longer open a console window.

## 1.9.130 [#19130]

* Claude Code: setup, `pushary upgrade` and the hook repair at session start keep your own allow rules that mention Pushary, such as `Bash(pushary doctor)` or a project folder named `pushary-app`. Before, every rule containing the word "pushary" was deleted each time the settings were rewritten, so Claude Code asked again for commands you had already allowed. `pushary disconnect` and `pushary clean` deleted them too. Only the rules that allow Pushary's own tools are replaced or removed now.

## 1.9.129 [#19129]

* Claude Code shows a streamed reply with less delay. It waits for Pushary's display hook before it prints each batch of lines. That hook now loads as one file and no longer forces its short-lived preview to disk, so each wait drops from about 58 ms to about 42 ms on a recent Mac.

## 1.9.128 [#19128]

* Windows: a message from your phone reaches a phone-started Gemini session as you wrote it, and `pushary claude` hands Claude your arguments as you typed them. Before, an agent installed with npm was started through cmd.exe, which split the text into words, dropped everything after its first line and ran `&`, `|` and `>` as commands. `pushary claude -p` and piped runs no longer cut the agent off when you press Ctrl+C.

## 1.9.127 [#19127]

* The background daemon reads the record of a settled phone message to Codex or Hermes once, instead of every few seconds, and deletes its own records once they are more than 7 days old. Before, every record was reread on each scan and kept forever, so the work grew with every message.

## 1.9.126 [#19126]

* With two or more sessions taking turns, a tool call no longer fetches your policy again just because another session fetched it last, and each session can ride out an outage on its own copy. Before, nearly every call refetched, and an outage often left a session with no copy. When a new session starts, copies older than 12 hours are deleted.

## 1.9.125 [#19125]

* Linux: sessions started from your phone keep running when the background daemon stops or restarts, as they do on macOS. Before, systemd stopped them with the daemon on every restart and upgrade. The upgrade that installs this still restarts the daemon the old way, so sessions running at that moment stop once.

## 1.9.124 [#19124]

* Cursor: the Pushary gate runs on Windows and from a plugin folder whose path has a space or a symlink. Before, it printed nothing there, so Cursor blocked every shell command, MCP call and file edit it gates. The Cursor Marketplace plugin updates through Cursor; run `npx pushary@latest setup --agents cursor` to update a copy that setup installed.

## 1.9.123 [#19123]

* The background daemon keeps running after your computer wakes from sleep. Before, a transcript hook that ran in the first 30 seconds after a long sleep could stop it, and phone start, transcript upload and the Claude wake inbox stayed off until a later hook started it again.
* `pushary upgrade` keeps the Gemini CLI settings file and the Cursor and VS Code plugin `mcp.json` files, which hold your Pushary key, readable only by you, as setup writes them. Before, upgrade left them at your default permissions.

## 1.9.122 [#19122]

* Claude Code: a hook event removed from your settings now comes back at the next session start, whenever Pushary can find its installed hooks. Before, it stayed gone until Claude Code shipped a new version or you ran `pushary upgrade`. Newer events are not added back while the Claude Code version cannot be read.
* Claude Code: when Pushary cannot read which version of Claude Code is installed, it no longer removes the newer hook events, at session start or during `pushary upgrade`.
* Claude Code: the session start repair and `pushary upgrade` keep a private settings file private. The session start repair leaves a read-only settings file alone; `pushary upgrade` still rewrites one with your default permissions, as it did before.
* Claude Code: `pushary upgrade` keeps `~/.claude.json`, which holds your Pushary key, readable only by you. Before, it could reset the file to your default permissions.

## 1.9.121 [#19121]

* An `eval` is read only to the end of its own command, so a script written to a file with a line such as `eval "$(fnm env)" # setup` is no longer refused by an unrelated deny rule.
* A `Bash` allow beside a `*` routing rule keeps working for an explicit push.
* A long run of harmless `sh -c` commands can no longer hide a later script from a deny rule, and a command with more commented scripts than Pushary reads is refused under a deny rule.

## 1.9.120 [#19120]

* Claude Code: the kill switch and standing deny rules now apply to MCP tools, WebFetch and Task (Agent) even when Claude Code would not have shown a prompt, in every permission mode. Nothing new is ever asked on these calls: any other rule, a scope contract and every failure leave them exactly as before. Update or run setup to write the new hook entry. Terminal only for now; the Mac app does not write it yet.
* A failed mode check no longer gives one session the state fetched for another. Only a kill carries across sessions, because a site-wide kill looks the same in the cache. Anything else is treated as unknown.
* A Claude-shaped hook call that sends null for an optional text field such as `session_id` or `cwd` is now judged instead of passing through unread. `tool_input: null` stays refused.
* Cursor and VS Code gates now use the computer's id from `~/.pushary/machine-id` when it holds a valid UUID, so one computer no longer shows up as two and the phone stays quiet while you are at the desk. Sessions already running split once at upgrade. The gates only read that file, never create it.

## 1.9.119 [#19119]

* A quote or backslash inside a shell comment, or an escaped quote in a `$'...'` string, no longer hides the lines after it from deny rules, routing rules and the check on destructive commands.
* A Team routing rule now reads a push by where it lands, so `git push origin +main`, `git push origin HEAD:refs/heads/main`, `git push --delete origin main` and `git push --no-verify origin main` count as pushes to `main`, and a push forced by a flag or a `+` counts for a force-push rule. A teammate's Always allow no longer runs them. The policy cache has a new name, and until this update a CLI loses that kept Always allow on a workspace with command routes.
* A deny rule and the check on destructive commands now see a script fed to a shell by process substitution: `bash <(curl ...)`, `source <(...)`, `. <(...)` and `bash < <(...)` are read like the same text piped into `sh`. Before, they ran under a broad allow.
* Deny rules and routing rules now read `case ... esac` arms, `coproc`, a function whose body is a subshell, `npx -c`, `su -c` and `parallel`.
* A comment inside a script handed to a shell with `bash -c`, `sh -c` or `eval` no longer hides the lines after it.
* PowerShell commands get the same reading of comments.

## 1.9.118 [#19118]

* Every agent: silence can no longer approve a call outside the scope you agreed. Before, an Always-allow rule on Claude Code withdrew the question at once and ran the call. A scope question now waits for a real answer, then falls back to the agent's own prompt or refuses.
* Gemini CLI and OpenCode: a standing auto-approve no longer runs a call outside the scope you agreed. You are asked about it as a scope question, and it runs only on a yes. If nobody answers, it is refused.
* Gemini CLI, OpenCode and Cursor: silence refuses a call outside the scope, so that question is no longer cut to a short keyboard window on your phone. Cursor also no longer skips your phone when you are at the keyboard, since it has no prompt to fall back on.
* Gemini CLI and OpenCode now record a denial when the kill switch or a standing deny refuses a call.
* A policy the server has already replaced can no longer auto-approve while the hook is working from its cached copy. Pushary stands aside and the agent's own permission flow decides. Denies and the kill switch still apply.
* A mode response that does not state the kill switch now counts as unverified, not as "not killed".
* The Codex, Gemini and OpenCode hooks check what the agent sends before acting on it.
* Codex, Gemini and OpenCode now share one path for asking a question and waiting for the answer.

## 1.9.117 [#19117]

* The report a hook sends when a tool call finishes now also names the tool. Pushary uses this to tell whether a step a Team approval route sent to someone, which then went back to the agent's own prompt because nobody answered, went on to run, and to show that in Activity. It changes nothing about what runs or what is asked. A published CLI that does not send the name keeps working, and such a step is simply not marked.

## 1.9.116 [#19116]

* A push that names no branch, such as `git push`, `git push origin`, `git push origin HEAD` or `git push origin @`, now counts as a push to the current branch when a Team approval route names that branch. Before, a route on pushes to `main` did not match these, so a teammate's push to `main` that way never reached the lead. The hook reads the branch from the working tree. Nothing changes for a push on a branch no route names, a push that names a branch, `--tags`, `--dry-run` or `-n` (also in a cluster such as `-nv`), a push after `git checkout`, `git switch`, `cd`, `pushd` or `popd` in the same command, a push pointed elsewhere with `git -C`, `--git-dir` or `--work-tree`, or a command over 16 KB. Only approval routes read a push this way; other rules do not. When an Always allow covers the command, the route's own ask takes over so the step is asked. The Mac app, anything else that asks Pushary directly, and the `pushary` wrapper's approver send no branch, so for them a push must still name the branch to match a route.
* A shell command that starts with a program under `$HOME` or `$PWD`, such as `$HOME/.local/bin/uv run pytest` or `"$PWD/bin/tool"`, is now read by the program's name for approval rules and routes, the same as the command with the program spelled out. Beside a Team rule on `git push`, it no longer loses a teammate's Always allow. Only those two variables count, and only at the very start of the whole command: anything before it, such as an earlier command, an assignment or a wrapper, any other variable (`$VENV/bin/pytest`), and a program that is entirely a variable (`"$PYTHON" x.py`) stay as they were and keep asking. Nothing else in the CLI or the hooks changed.

## 1.9.115 [#19115]

Not published to npm. These changes first shipped in 1.9.116.

* In Claude Code's auto mode, an MCP tool call that a Team approval route sends to someone else now waits for that person. Before, MCP tools never reached the PreToolUse hook, so auto mode decided first and the approver was asked only if auto mode stopped to ask. If the approver says yes the call runs, and if they say no it does not. If nobody answers in time, the call does not run by itself: it goes back to the agent's own prompt, or is refused, as it does for a shell command in the same case. The hook decides only for a route that names the tool and that someone other than the person running the agent can answer. A route for every tool (`*`) does not hold an MCP call, so auto mode still decides first there. In every other case, and in every other permission mode, it gives no opinion and makes no network call: it checks the policy already cached on this computer and stops there. Measured on a busy Mac, the whole hook run adds about 130 ms to an MCP call. So an MCP call in default mode keeps its one ask from the PermissionRequest hook, never two.
* A route holds an MCP call only once the policy saved on this computer includes it. The hook's other calls, such as a shell command or file edit, save the policy as they run. An MCP call that comes first, with no policy saved in the last 12 hours, or before a new route has been saved, is decided by auto mode as before.
* `pushary setup` and `pushary upgrade`, including the automatic update, add one PreToolUse entry with the matcher `mcp__.*` for the same hook. Your other hooks and settings are not rewritten. A settings file without this entry keeps today's behaviour: the PermissionRequest hook still asks.
* This covers the CLI only. The Mac app writes its own hook settings and is unchanged until it is updated. Web fetches do not change: auto mode decides first, and the approver is asked only if auto mode would have stopped to ask.

## 1.9.114 [#19114]

* `pushary setup` now adds a step under "Still to do", and under `manualSteps` with `--json`, when Codex is too old for hooks or setup could not read its version. The exit code and the `ok` field are unchanged.

## 1.9.113 [#19113]

* In Claude Code's auto mode, a shell command or file edit that a Team approval route sends to someone else now waits for that person. Before, PreToolUse stepped aside for these calls in auto mode, so Claude Code's own check could run them without the approver seeing them. If the approver says yes the call runs, and if they say no it does not. If nobody answers in time, the call does not run by itself: it is refused or goes back to the agent's own prompt, as it does outside auto mode. Only a matching route that someone other than the person running the agent can answer counts, so a lead's own agent does not wait for the lead, and a workspace without Team routing does not change. MCP tools and web fetches do not change: auto mode decides first, and the approver is asked only if auto mode would have stopped to ask. Kill switch, standing deny and standing allow rules come first as before. A person on the In agent or Alert only approval mode gets no new prompt, and a phone-only rule set to approve when nobody answers does not hold the call. `plan`, `dontAsk` and `acceptEdits` do not change.
* A tool call a Team route matches now reaches the person the route names, even when the server cannot see the whole call. Before, the server saw only the file extension of an edit and a shortened copy of a very long command, so a rule such as `Edit(src/**)` missed and the question went to the person running the agent. The hook now tells the server which rule it matched. No extra path or command is sent for this.

## 1.9.112 [#19112]

* `pushary setup` no longer ends with "You're set" or "Setup complete." when Codex cannot gate every tool call yet. The test question proves your phone gets questions, not that Codex waits for you. When this Codex is too old for hooks, or setup could not read its version, and it got the notify handler, the last line reads "Agents configured. Codex approvals are not on yet." When Codex does not run every Pushary hook, it reads "Agents configured. Codex is not running every Pushary hook yet." That covers Codex refusing the trust and a hook turned off in Codex. When setup did not ask Codex (no terminal, as when an agent runs setup, Codex not opened yet, or the Codex inside the ChatGPT app), setup reads Codex's own files instead: hooks turned off in `config.toml`, a turned-off or asynchronous approval hook, or a hook that is not trusted. Setup then prints a warning in place of "Hook pre-trusted", and adds the same step to the steps still to do, which `--json` lists under `manualSteps`. After an answered test question the line keeps the answer, as in "Your phone answered in 3s. Codex is not running every Pushary hook yet." One line follows that says what to do. The exit code, the `ok` field and the reason setup reports are unchanged, so scripts and agents that run setup see the same result. A Codex that confirmed the trust, or that Pushary pre-trusted with every hook on, ends as before. Checked against the real Codex 0.167: when setup says complete, Codex runs the PreToolUse hook before a command, and when PreToolUse is turned off, or hooks are turned off in `config.toml`, setup no longer says complete and Codex runs the command without the hook, whether or not setup asked Codex. Nothing else in the CLI or the hooks changed.

## 1.9.111 [#19111]

* A deny or ask rule, and an approval route, on a command now also catch that command when one of these runs it: `uv run`, `poetry run`, `pipenv run`, `hatch run`, `rye run`, `pdm run`, `pixi run`, `conda run`, `pipx run`, `volta run`, `bundle exec`, `asdf exec`, `rbenv exec`, `pyenv exec`, `nodenv exec`, `goenv exec`, `jenv exec`, `plenv exec`, `nvm exec`, `direnv exec`, `docker exec`, `kubectl exec`, `devcontainer exec`, `pnpm exec` or `dlx`, `yarn exec` or `dlx`, `npm exec` or `x`, `bun x`, `mamba run`, `micromamba run`, `op run`, `dotenv`, `script`, `nix develop -c` or `nix shell -c`; the command after `--` in `doppler run`, `infisical run`, `aws-vault exec`, `chamber exec`, `mise` or `rtx` `exec` and `x`, `op run`, `kubectl` and `oc` `exec` and `run`, `docker exec`, `docker compose`, `docker-compose exec` and `run`, `podman exec`, `nerdctl exec`, `flox activate`, `devbox run`, `fnm exec`, `dotenvx run`, `teller run`, `berglas exec`, `nx exec`, `lerna exec`, `stack exec`, `cabal exec`, `opam exec`, `tox exec`, `aqua exec`, `pixi exec`, `hermit exec`, `toolbox run`, `railway run`, `heroku run`, `secrethub run` and `phase run`; the command strings of `script -c`, `npm exec -c`, `mise exec -c`, `nix-shell --run`, `flox activate -c`, `doppler run --command` and `sops exec-env`; and a shell function defined in the same command and then called, directly or through a wrapper such as `time` or `FOO=1`. A rule on `Bash(git push:*)` now asks about `uv run git push --force` and `f(){ git push -f; }; f`. A runner whose command is a variable or a command substitution, such as `uv run "$CMD"` or `uv run "$(which git)" push`, counts as hiding what it runs, and so does a command that defines more than eight shell functions. A command with more than 4,096 spellings, or one that cannot be read, also counts as destructive, so a `*` or `Bash` approve rule, bypass or a preset never approves it.
* The hook reads every call with and without these runners. A refusal beats a question and a question beats an approval. When both readings ask and neither is at least as strict on every count (the delivery mode, what happens unanswered, how long it waits and how long the terminal gets first), it asks with the stricter value of each, so nothing that was asked or refused is now approved and no question gets a weaker wait or a weaker answer on timeout. Not read: runners outside the list above (`yarn workspace <name> exec`, `dune exec` and `docker run <image> <command>` among them), the `--` runners above without `--`, such as `devbox run git push`, `mise exec` with tools and no `--`, a function called only from another function or through `eval`, and an attached command string such as `script -qc'git push'`.
* The hook caches the policy as `pushary-policy-v2-<hash>.json` in your temp folder, and asks for it with an `x-pushary-policy-capabilities` header naming what this CLI reads. Earlier CLIs keep their own cache files and never read this one, and this CLI ignores theirs and fetches again. Nothing else in the CLI or the hooks changed.

## 1.9.110 [#19110]

* When Pushary's server says the key this computer sends is not valid (an unknown or revoked key, an expired connector key, or a value that is not a Pushary key at all), the CLI now remembers that for 60 seconds and sends no requests with that key in the meantime. During that minute, everything that would have asked the server gives exactly the answer it gives after that refusal today, with the same decision and the same message: the agent hooks, the `pushary-mcp` bridge, the MCP check in `pushary doctor`, the test approval in `pushary setup`, the Codex bridge and its native approvals, and session history capture. The memory is kept per key and per server in the temporary folder, holds a one-way hash of the key and never the key itself, and is ignored once it is older than 60 seconds or cannot be read. A different key, including a new one from `pushary login` or `pushary setup`, is used at once. A refusal about the plan or a key's permissions, a server error and a network failure are not remembered. A value that is not a Pushary key is remembered even while Pushary's sign-in service is having an outage, because no outage can make it a valid key. A server without this release sends no signal, so the CLI keeps asking it as before.

## 1.9.109 [#19109]

* On a Team workspace, approval routes now apply to the Codex app permission cards that Pushary forwards: Computer Use using an app or recording audio, and Browser use opening a site, downloading or uploading. Each card matches a route as the tool Codex raised it in, such as `mcp__cua_repl__get_app_state` or `mcp__cua_repl__access_browser_origin`, and a route for every tool matches them too. Nothing else in the CLI or the hooks changed.

## 1.9.108 [#19108]

* After a successful `pushary setup` on the Agent or Agent Pro plan, setup prints one more line after the "Useful" list: "On a team? Send risky steps to a lead and see who approved: pushary.com/teams". It is not shown on Team, Partner, Enterprise or e-commerce plans, when setup could not check the plan, or when setup did not succeed. Nothing else in the CLI or the hooks changed.

## 1.9.107 [#19107]

* On Windows, the hook now reads Claude Code's managed settings from `C:\Program Files\ClaudeCode\managed-settings.json`, where Claude Code reads them. It read `C:\ProgramData\ClaudeCode\managed-settings.json`, which Claude Code no longer reads, so an organization's managed allow, ask and deny rules were missing when Pushary checked whether Claude Code's own rules already cover a tool call, and from the hook wiring report. macOS and Linux are unchanged. Nothing else in the CLI or the hooks changed.

## 1.9.106 [#19106]

* The test approval at the end of `pushary setup`, and the one `pushary doctor` sends, now wait the full 55 seconds for your tap. Since the server began ending each wait after at most 48 seconds, so that agents' tool calls stay inside their hosts' time limits, the check made one wait, read the early "still pending" as nobody answering, and cancelled the question on your phone. A tap between 48 and 55 seconds was reported as "nothing came back". The check now keeps waiting while the question is pending, up to its own 55 second window, and still cancels the question if nobody answers in time. Pressing Ctrl-C while it waits stops the waiting at once. The bundled Pushary skill now says one call waits at most 48 seconds. Nothing else in the CLI or the hooks changed.

## 1.9.105 [#19105]

* The background daemon now reports, on the heartbeat it already sends each minute, whether Pushary's hooks are still in place for each agent on the computer: wired, untrusted, weakened, missing, unreadable or disconnected. A hook counts only when it really runs Pushary's own binary for that event. Each agent is named with a short hash of the computer's id and its config file's path, never the path itself. If building the report fails, the heartbeat goes out without it, as before. Nothing else in the CLI or the hooks changed.

## 1.9.104 [#19104]

* New: `pushary audit verify <file>` checks a verifiable audit export from Dashboard > Agent > Activity > Verifiable, with no account and no network. It recomputes every hash in the chain, checks the signatures, and compares the file against what it verified on earlier runs (signed checkpoints, the newest entry seen, and every site seen), kept in `~/.local/share/pushary/audit-checkpoints.json`, where `pushary clean` leaves it. A changed row, an answered decision changed afterwards, a missing entry, a bad signature, or a history that was rewritten or cut short prints `CHANGED` and exits with code 5. A file where something could not be confirmed, such as an older page, a file with no signed checkpoint or only an old one, a row removed early, a signing key this version does not pin, or checkpoints this run could not save, exits with code 9, never 0. A file with no entries yet exits with code 3. Nothing else in the CLI or the hooks changed.

## 1.9.103 [#19103]

* The Hermes plugin Pushary installs is now 1.0.1. When it hands a Hermes session to Pushary's history helper, the helper now gets only what it reads: the home folder, the search path, the temporary folder and locale, the Pushary settings it uses, and the Pushary key Hermes holds. Hermes' other provider keys no longer reach it. Checking whether history is allowed sends the key on standard input only.

## 1.9.102 [#19102]

* The Hermes plugin Pushary installs is now 1.0.0. In Hermes Desktop, a Pushary chip in the status bar shows the approvals waiting on your phone, and you can answer them there too. Only one answer counts: a Hermes Desktop answer is used only when Pushary confirms that answer is what withdrew the question, and otherwise the panel says the approval had already closed. The chip also lists how recent approvals ended and where they were answered. Enable Pushary under Capabilities, Plugins in Hermes Desktop to see it.
* On a Team workspace, a Hermes approval that an approval route sends to someone else, with "Only they can answer" on, is no longer handed to Hermes' own prompt. The plugin waits for the route's approvers until Hermes' timeout and denies if none of them answers.
* When Hermes has already given up on an approval, because it timed out or the turn was interrupted, the plugin withdraws the question from your phone at its next check instead of leaving it open.

## 1.9.101 [#19101]

* When npm cannot write to its global folder (an `EACCES` from a system Node install on Linux, for example), setup now reports that same reason for every agent it connects, and tells each one to fix the npm prefix. Before, only the first agent got that reason. The others said an earlier installation "did not finish safely" and to retry, which could not work.
* After you fix the npm prefix, setup, `pushary upgrade` and the daily automatic update run again on their own. Before, they kept refusing until you deleted `~/.pushary/auto-update.lock` by hand. If an earlier version already left that file behind, delete it once; 1.9.101 cannot tell whether the install it records finished.
* Every other failed install still blocks the next one until you clear it, as before: one that timed out or was stopped, even after npm printed a permission error; one whose output names no permission error; and an `EPERM` on Windows, where another program may still hold the files.

## 1.9.100 [#19100]

* With Claude Code's permissions off, Pushary now asks before git sends your code to a place the command names:
  * a `git push` whose repository, or `--repo` value, is a URL or host address, such as `git push https://example.com/acme/app.git main`, `git push git@example.com:acme/app.git HEAD`, `git push --all` to a URL, or `git push --repo=` with a URL. A repository held in a variable, such as `"$PUSH_URL"`, asks too;
  * `git remote add`, in any form;
  * `git send-pack` and `git http-push`.
* A push to a remote the repository already has runs as before, such as `git push`, `git push origin main`, `git push -u origin feature/x` or `git push origin HEAD:refs/heads/x`, and so does a push to a local folder, `git fetch` or `git ls-remote` from a URL, `git remote -v` and `git remote show`. Force, tag and delete pushes ask as before.
* "Never stop me" still lets every step run. Every other Claude Code mode, every other agent, and Always allow for Bash judge commands exactly as 1.9.99 did.
* Not asked about yet with permissions off: a repository given by a command substitution such as `$(cat file)`; the command in `--receive-pack`, `--exec` or `--upload-pack`; settings that send a plain push somewhere else, such as `remote.pushDefault`, `branch.main.pushRemote` or `branch.main.remote`; the `git -c` form of a setting that runs a program, such as `core.sshCommand`; `--config-env` and the `GIT_CONFIG_*` variables; `git.exe` in Bash; `xargs git push`; and `git subtree push` and `git lfs push`.

## 1.9.99 [#1999]

* When you drive a terminal session from your phone through `pushary claude`, you get the "finished" push at the end of each turn again while Pushary for Mac is running. Since the server stopped pushing every clean turn end, the turn ended quietly in that setup, because the wrapper did not say the phone was driving. The wrapper now says so on each turn end and on each phone instruction it runs, so a phone instruction also no longer marks your Mac as at the keyboard. A turn that ends on an error, such as a rate limit, says it failed and why instead of "finished".
* With Claude Code's permissions off, Pushary now also asks about:
  * changing a package's owners, dist-tags, access or team with `npm` or `pnpm` (`owner add`, `dist-tag add`, `deprecate` and the like), or `yarn owner` and `yarn tag` changes; listing them still runs;
  * uploading a build to Apple with `xcrun altool --upload-app`, `--upload-package` or `--notarize-app`, or `xcrun notarytool submit`;
  * sending mail with `sendmail`, `msmtp` or `ssmtp`, or with `mail`, `mailx` or `mutt` to an email address;
  * changing where git sends commits: `git remote set-url`, a `git config` value for a remote's `url` or `pushurl` or a `url.<base>.insteadOf` rewrite, or the same with `git -c` on a push (`git remote -v`, `git config --get`, `git remote add` and `git -c` on a fetch still run);
  * `shutdown`, `reboot`, `halt` and `poweroff` (`shutdown -c` still runs);
  * an edit to, or a shell write into, a git hook in `.husky/`, a direnv `.envrc`, `.vscode/tasks.json`, `~/.npmrc`, `~/.netrc`, `~/.kube/config`, `CLAUDE.md`, `CLAUDE.local.md`, `AGENTS.md`, `AGENTS.override.md`, or a file in `.claude/commands/` or `.claude/agents/`. Reading them still runs.
* Every other Claude Code mode, every other agent, and Always allow for Bash judge commands and file edits exactly as 1.9.98 did.
* After `pushary login --force`, `setup` no longer replaces the new key with the old one your terminal still exports, however many times it runs. The first setup keeps the new workspace as before. A later setup in a terminal that still exports the old key, because it is the same terminal, you exported it again on purpose, or direnv did, asks "Continue as @your-new-workspace?" with yes as the default, and no moves this computer back to the old key. With nobody at the terminal it keeps the new key and says to run `login --force` to move back on purpose.

## 1.9.98 [#1998]

Not published to npm. These changes first shipped in 1.9.99.

* After `pushary login --force` moves this computer to another workspace and updates the `PUSHARY_API_KEY` line in your zsh or bash profile, `setup` in the same terminal now keeps the new workspace instead of saving the old key back over it. Login and setup say which workspace each key belongs to.
* When Pushary cannot be sure your terminals read the profile it updated (a `PUSHARY_API_KEY` line it did not write, a profile it cannot replace, a shell other than zsh or bash, or Windows), login and setup no longer say new terminals use the new key. They tell you to change `PUSHARY_API_KEY` where it is set if new terminals still get the old one, and setup keeps following the key your terminal has, so your agents and their approvals stay in one workspace. A key set by a tool such as direnv is not detected.
* The browser sign-in page lists your workspaces by name, with the plan when there is one, and leaves out sandboxes, workspaces where you only view, and shops. It preselects the Team workspace you chose to connect to, when there is one, and otherwise the workspace open in the dashboard.

## 1.9.97 [#1997]

* Asking only about risky steps with permissions off is now for Claude Code's `--dangerously-skip-permissions` alone. Codex in every approval mode, and every other agent that reports `bypassPermissions`, gates exactly as it did in 1.9.93 again: `codex exec` reports that mode whatever its approval policy is, so in 1.9.94 to 1.9.96 a routine call that used to reach your phone ran without a question.
* With Claude Code's permissions off, Pushary now also asks about:
  * an upload with `scp` or `rsync` to another machine, `sshpass` included (an rsync dry run still runs);
  * a secret written to a host (`doppler secrets set`, `vercel env add`, `fly secrets set`, `heroku config:set`, `netlify env:set`, `railway variables --set`, `supabase secrets set`, `wrangler secret put`, Firebase function secrets, `gcloud secrets`, `az keyvault secret set`), also through `npx`, `pnpm`, `yarn` or `bun` with a version;
  * `gh workflow run`, `enable` and `disable`;
  * pushing a tag named `v` and a number, such as `v1`, unless the push sets an upstream branch;
  * a `git config` setting that runs a program, such as `core.fsmonitor`, `core.sshCommand`, a pager, a credential helper other than the usual ones, a diff or merge driver or tool, a filter, an include, `protocol.allow`, or an alias or submodule update that starts with `!` (switching a setting on or off still runs, except for an include);
  * a PowerShell `Invoke-RestMethod` or `Invoke-WebRequest` that sends data off the machine;
  * an edit to, or a shell write into, a shell profile such as `~/.zshrc` or `~/.bash_aliases`, `~/.zsh`, `~/.zshrc.d`, `~/.config/zsh`, Oh My Zsh, Powerlevel10k's `~/.p10k.zsh`, a systemd user unit, `~/.gitconfig` and its included files, `.git/config`, `.mcp.json`, `.cursor/mcp.json`, `.claude/hooks`, a launch agent or daemon, the PowerShell profile, a file in `/etc`, or the CLI's own cached policy and mode files.
* With Claude Code's permissions off, `ssh host uptime`, `free`, `who`, `docker ps`, `docker logs`, `systemctl status` and `journalctl` now run without a question. Reads, downloads, local copies and `git push origin main` run as before.
* Every other Claude Code mode, and Always allow for Bash, judge commands exactly as 1.9.96 did.

## 1.9.96 [#1996]

* With permissions off (`claude --dangerously-skip-permissions`, or Codex set to never ask), a workspace can now choose to never be stopped. Settings has a new choice, "When your agent skips permissions": "Stop me for risky steps" (the default, as in 1.9.94) or "Never stop me", which lets every step run, a merge under an Always allow for Bash included. Your own ask and deny rules, presets, approval routes, the kill switch and a scope you approved still apply.
* A card asked only because a step is risky while permissions are off now says so: "Permissions are off in your agent, so Pushary only stops for risky steps like this one."

## 1.9.95 [#1995]

Not published to npm. These changes first shipped in 1.9.96.

* The wider checks 1.9.94 added now apply only with permissions off (`claude --dangerously-skip-permissions`, or Codex set to never ask). In every other mode, Always allow for Bash, a Bash grant for one session, commands you allowed in Claude Code's own settings, Codex's own prompts and paused asks judge commands and file edits exactly as 1.9.93 did. So outside permissions off, `gh secret set`, a `gh api` delete, a `curl` upload, a tag push, `eas submit` and an edit to an agent's settings, a git hook or `~/.ssh` are handled as before. With permissions off nothing changes from 1.9.94.

## 1.9.94 [#1994]

* With `claude --dangerously-skip-permissions`, or Codex set to never ask for approval, Pushary now asks only about what Always allow for Bash would still ask about (such as `gh pr merge`, `git push --force`, `npm publish`, `vercel --prod` or `rm -rf`), an edit to `.env` or a CI workflow file, a Codex patch that deletes a file, and a connected app that writes. Routine commands, other file edits and connected apps that only read run without a question. Before, every gated call asked, and nearly every answer was yes. A plain `git push` runs; add a rule for `Bash(git push:*)` to be asked about it. A rule you wrote, a preset you picked, an approval route, a mode override, the kill switch, your deny rules and a scope you approved all still apply. `PUSHARY_DEFER_BYPASS=1` still leaves these sessions to the agent entirely.
* Always allow for Bash, a Bash grant for one session, and the sessions above now also ask about: a `gh api` request with `DELETE`, a `PUT` or `PATCH` outside issues, pull requests and their comments, reviews, labels, assignees and reactions, and notifications, a merge, release, webhook, tag or branch made through `gh api`, and a GraphQL mutation that deletes, archives, transfers, merges, changes branch protection, or creates a ref or commit; `gh secret set`, `gh variable set`, `gh repo edit --visibility`, `gh repo create --public`, `gh repo archive`, `gh repo rename`, and adding an SSH or GPG key with `gh`; a Stripe write that may reach live data (`--live`, a live key, or a key held in a variable passed with `--api-key` or `STRIPE_API_KEY=`), and any AWS or Twilio CLI command that writes; `curl` or `wget` sending data anywhere but this machine; `kubectl exec` or `ssh host command` that does more than read, and `kubectl patch`, `edit`, `set`, `create`, `drain`, `cordon` and `taint`; `eas submit`, `update`, `deploy` and `channel:edit` (through `npx` or `pnpm dlx` too), a build with `--auto-submit`, and fastlane store uploads; pushing a tag, including one named by a variable such as `$TAG`; setting `core.hooksPath` with `git config` or `git -c`; `eval` of a command's output, unless it is one of the usual shell setups such as `fnm env`, `brew shellenv`, `starship init` or `poetry env activate`; downloaded or decoded code piped or passed into a shell or interpreter; and `node -e`, `python -c`, `bun -e`, `deno eval` or heredoc code, also through `uv run`, `poetry run` or `pnpm exec`, that removes a folder, runs decoded code with `eval` or `exec`, spells a command that would ask on its own, or writes one of the files below. Under Always allow and with permissions off, opening, editing and commenting on issues and pull requests, a `gh api` read, a Stripe command in test mode, `curl` to `localhost` (including `localhost:$PORT`), and one-liners that only read, print or delete a single file still run. A Bash grant for one session keeps asking about network calls, as before. A command you allowed in Claude Code's own settings is judged as before, outside bypass.
* An edit to an agent's own settings now asks, the way an edit to `.env` does: Claude Code's `settings.json`, `settings.local.json` and `~/.claude.json`, Codex's `config.toml` and `hooks.json`, OpenCode's `opencode.json` and plugins, and the hook settings of Cursor, Gemini CLI, Qwen Code, Factory and Hermes. So does an edit to anything in `~/.pushary`, a git hook in `.git/hooks`, or a file in `~/.ssh` other than `known_hosts`, and a shell command that writes, copies into, moves over or removes one of them (`{a,b}` spellings included), in a POSIX shell or PowerShell. Pushary reads the command it is shown; a script the agent writes and then runs is not read.

## 1.9.93 [#1993]

* After phone pairing, setup lets you choose an agent when automatic detection finds none and you are at an interactive terminal. Detected agents still configure automatically. Explicit automatic selection and unattended runs still stop without configuring an agent when none is detected; the paired key stays saved.

## 1.9.92 [#1992]

* Team workspaces can connect reported tool actions to the corresponding human decision when the agent supplies that evidence. Missing outcomes stay unknown.

* Reported repository branch and commit evidence appears in the optional engineering sprint record.

* In a repository with no git remote, "Always allow ... in this repository" now also covers that repository's linked git worktrees, such as the ones Claude Code creates for parallel subagents under `.claude/worktrees/`. Pushary named each worktree, or the folder inside it the agent was working in, as a repository of its own, so allowing edits for one subagent did not reach the others and they kept asking. Rules saved in the main checkout, denies included, now apply in its worktrees.

* Existing worktree-specific denies remain enforced. Existing worktree-specific allows do not expand to the whole repository; you may be asked again. New repository grants apply across its linked worktrees.

* A repository checked out inside a folder named `worktrees`, or itself named `worktrees`, is now identified by its git remote, so a rule saved for that repository from another checkout applies there. Existing denies saved under its folder name remain enforced; existing allows do not expand silently.

* A submodule inside a linked worktree is identified as its own repository instead of as the superproject.

* With no git remote, worktrees of a bare repository named like `project.git`, or of one made with `--separate-git-dir`, are still identified one by one.

* The Cursor and VS Code gates name repositories the same way, and on Windows they now recognise the worktrees Git for Windows creates by default. An installed gate is replaced when you run `npx pushary@latest setup` again; `pushary upgrade` does not replace it.

## 1.9.91 [#1991]

* `pushary setup` no longer fails just because Stop all agents is on. The stop used to hold back setup's test notification, so for that hour every setup said your phone was unreachable. The stop no longer holds it back. In setup and `pushary doctor --roundtrip`, the test question now says the agents are stopped and when the stop lifts, instead of saying nobody answered.
* When approvals are set to In agent, setup and doctor no longer wait 55 seconds and then report that nobody answered a test question that never went to your phone. They say where the question went and how to get approvals on your phone again. The same goes for a mute set from your phone.

## 1.9.90 [#1990]

* Gemini, Cursor and Hermes history read from their session files no longer trusts a new phone key on first use when this computer already trusts a phone for its Claude and Codex history. A session started after the phone moved uploads nothing until you verify the new phone with `pushary transcripts trust --fingerprint <fingerprint-from-phone-settings>`, then follows it. A computer that has never trusted a phone still trusts the first one it is offered.

## 1.9.89 [#1989]

* Verify a replacement phone with `pushary transcripts trust --fingerprint <fingerprint-from-phone-settings>` without resetting pairing, original recipient pins or conversation keys. Changed recovery recipients remain blocked. History captured by the Mac app uses its new Reconnect phone control after updating the app. Previously locked history still needs recovery access; verification cannot recreate missing keys.
* Corrupt history trust files pause uploads and use the existing retry backoff. Restoring the original files resumes capture without restarting or changing conversation keys.

## 1.9.88 [#1988]

* The bundled Pushary skill is 0.13.1. It says what each `status --json` exit code means, when to follow plain `status` instead and where its printed steps need care, lists every agent id setup accepts, and says that when `status --json` reports `connectedThroughMacApp: true`, agents other than Cline are connected in the Mac app.
* An agent still asks an approval it cannot continue without after three pushes, wherever you are, instead of waiting in a chat nobody reads.
* The skill's reminder and notification guidance matches the server: a reminder body over 180 characters fails, and an agent does not say it notified you when nothing was pushed.
* The bundled Cowork and Hermes skills say a Partner customer can answer on a Mac they connected from their phone. They used to say they could not. Hermes plugin 0.9.2 carries the same fix.
* The instruction block setup writes no longer says the Mac notch answers only personal questions. `pushary upgrade` refreshes it for Codex, Gemini CLI, OpenCode, fx, Cline, Qwen Code, CodeBuddy and Grok Build. Agents the Mac app connected get it with the next Mac release, and a project CLAUDE.md or AGENTS.md keeps the old line until setup writes it again.

## 1.9.87 [#1987]

* On Node.js older than 22.20, setup installs the Pushary skill with skills.sh CLI 1.5.0. Newer versions of that CLI need Node 22.20, so on older Node every setup failed there, fell back to the bundled copy, and spent several seconds doing it.
* The npm description now says what Pushary is: human-in-the-loop (HITL) for AI agents, so a search for human-in-the-loop on npm can find it.

## 1.9.86 [#1986]

* Long Gemini and Cursor sessions keep syncing to your phone. A session past 20 MB or 5,000 messages used to stop syncing altogether, and the phone said "History sync needs attention". Pushary now sends the newest 5,000 messages, up to 20 MB, and keeps up as the session grows. Claude Code and Codex sessions already had the same 20 MB limit for earlier conversation. Older messages your phone already has stay there, and still disappear from it when the agent rewinds past them, for the 20,000 messages before the newest 5,000. Conversation that Pushary passed over while workspace history was off is still never sent, even when a rewind brings it back within the limit. A session that was stuck over the old limit could not pass over anything, so its newest part uploads once after this update. Session files up to 64 MB are read.
* Gemini, Cursor and Hermes conversation files are read again only when they change, or once a minute, instead of every three seconds.
* The Mac app's history helper gets this in its next release.

## 1.9.85 [#1985]

* Ordinary `pushary clean` keeps the Mac app's saved history choices for each workspace when the app is still installed. This publishes the cleanup entry added for Mac 0.1.118 after CLI 1.9.84 was built. Explicit full removal still removes those choices.

## 1.9.84 [#1984]

* When an owner or admin turns session history off for the workspace, Pushary passes over the conversation written while it is off, so turning history back on starts from that moment instead of uploading the gap. This needs Pushary running on that computer while history is off. A session left unused for more than two days and then resumed is read as a new session, so its recent part can still upload, including what was written while history was off. The Mac app's history helper gets this in its next release.
* The background service remembers how far it has read each conversation across restarts, so an upgrade or reboot no longer re-reads and re-sends the recent part of every conversation.
* Long Gemini, Cursor and Hermes sessions no longer re-upload the whole conversation each time an old message passes the history window.
* If Claude Code accepts the background service's wake three times while a phone instruction still has not arrived, Pushary stops waking that session for half an hour instead of starting a new turn every minute. Your phone says the instruction is waiting for activity in that session. A session that closes and opens again is woken again.
* `pushary transcripts trust --rotate` now also clears the phone key that Gemini, Cursor and Hermes history was pinned to, for every Pushary account the command line uses on this computer, so those sessions resume after a phone key change.
* Hermes (plugin 0.9.1): session history is exported only for the Pushary account this computer is signed in to. The check used to compare the key it was given with itself, so it allowed any key. A computer where only Hermes has the key, because `npx pushary@latest setup` never ran there, no longer saves Hermes history; the plugin says so once per Hermes process.
* Hermes: the history exporter rewrites its local snapshot only when the conversation changed, and asks the CLI for permission about once a minute instead of every five seconds. A session too large to export is no longer read again every five seconds.
* Hermes: local conversation snapshots in `~/.pushary/hermes-history` are deleted after 48 hours without a change.
* Hermes sessions no longer show `.hermes` as their folder on your phone.

## 1.9.82 [#1982]

* The background service that starts sessions from your phone now survives `brew upgrade node`. On a Mac or Linux computer where Node.js comes from Homebrew, it was pinned to Homebrew's versioned Node.js folder, which the upgrade deletes. Setup, `pushary upgrade` and `pushary daemon install` now pin it to Homebrew's stable link, and `pushary doctor` says when a service is still pinned to a version folder.
* Windows: when Node.js is installed in Program Files, as the official installer and winget do, Codex and OpenCode hooks now start it by its full path, so they no longer depend on Node.js being on the agent's PATH. Other agents and other Windows setups keep the hooks they had.
* Windows: Claude Code hooks keep working after `pushary upgrade`, an automatic update, or a Claude Code update. Those rewrote the hooks with the full path of the npm folder, which Git Bash, where Claude Code runs hooks, cannot read, so every Pushary hook in Claude Code failed silently. They now keep the plain names setup writes. If Claude Code on Windows stopped reaching your phone, run `npx.cmd pushary@latest setup` once.
* `pushary doctor` also checks that the Node.js a hook names still exists.

## 1.9.81 [#1981]

* While setup waits for your phone, it no longer suggests `--connect browser`. That sign-in needs a terminal, so an AI agent running setup for you got "No API key" when it followed the hint. The Ctrl+C screen now offers the app download, or a key you already have. `--connect browser` and `--connect web` still work for scripts that use them, and a mistyped `--connect` value now suggests only `app` or `none`.
* `setup --help` now says what happens without a terminal: setup asks nothing, configures the agents it detects and takes every default. It used to say such runs need `--agents` or `--yes`, which was not true.
* The bundled Pushary skill tells agents to run setup in the background and show you the link while it waits, and to run `doctor --roundtrip` afterwards, because setup run by an agent sends only a test notification. It also names the approval modes as the app does and says new workspaces start on Always.

## 1.9.80 [#1980]

* Setup no longer freezes while it installs the Pushary skill through skills.sh. The install takes about as long as before, but the terminal stays responsive, and each agent still gets its own install, so skills.sh records them as before.
* Setup asks npm where its global folder is once per run instead of six or more times. That saves up to about two seconds a run on macOS, Linux and Windows.
* Windows: Ctrl+C reaches the hermes commands that setup, doctor, clean and upgrade run again. 1.9.78 had given them a hidden console of their own.

## 1.9.79 [#1979]

* Windows: an instruction from your phone that arrives as Claude Code finishes its turn reaches Claude in that turn again. Since 1.9.75 Windows refused one step of saving it, so it waited until you next typed in the terminal.
* A session that already syncs its history no longer asks for the phone key every three seconds while history is off for the workspace or the server cannot answer. It waits up to a minute between checks and resumes at the first check after the key is available.
* When Pushary wakes an idle Claude Code session, the wake message no longer becomes the session title on your phone or the request text on the next approval card. Session titles that CLI 1.9.75 to 1.9.78 send from a wake are ignored too.
* A wake from your phone no longer counts as you typing at the computer. In When away mode, the approval that follows it reaches your phone, unless you typed in that terminal in the last five minutes.
* A phone instruction that could not be saved because the disk was full is saved on the next try, once there is space.
* The background service logs a missing Codex or Hermes connection once, not every three seconds.
* Codex app: the cloud exec-server that ChatGPT starts no longer makes Pushary say the Codex app needs a restart before approval cards work.
* Claude setup text points to the Pushary listing in Claude's connector directory. Pasting the connector URL still works.
* The Claude Code plugin from Pushary/pushary-skill, version 0.2.4, no longer registers the live reply preview hook. Started through `npx`, that hook ran past its one-second limit, so it held each reply for a second and never sent a preview. Existing plugin installs change after the plugin repository is updated and the plugin is updated in Claude Code with `/plugin update`. `npx pushary@latest setup` still installs the hook as a local command.
* Since 1.9.75, setup after a phone pairing configures every agent it finds, checks the connection with a test notification without waiting for an answer, and does not offer to edit CLAUDE.md or AGENTS.md or add a `claude` alias. Pass `--agents` to choose agents yourself.

## 1.9.78 [#1978]

* Setup wires Hermes faster and no longer freezes while it does. A fresh install runs the `hermes` command 10 times instead of 19, reads Hermes' settings in parallel, and does not check Hermes again after the install already read it back. Running setup again on a machine that is already set up runs five commands and changes nothing in Hermes.
* Hermes gets time to load the plugin into its running gateway. Setup used to stop waiting after 20 seconds, which could leave the plugin enabled without its tools and report the install as failed. If Hermes still takes longer than three minutes, setup now says so and tells you to run `hermes plugins disable pushary`, then setup again. That is also how to repair a machine an earlier setup left without the tools; running setup again alone does not.
* Setup no longer says it removed the old pip copy of the Hermes plugin on every run when there was none to remove.
* `pushary doctor`, `clean` and `upgrade` read Hermes the same way.
* Codex connection checks no longer count the cloud task helper the ChatGPT app starts as a Codex that still needs a restart.
* The Claude connector steps the CLI prints now start from Pushary's listing in the Claude directory.

## 1.9.77 [#1977]

* Sync displayed Gemini, Cursor and Hermes conversation history to compatible phones, including edits and rewinds. Cursor exports have no source timestamps and omit some tool details; existing undated turns remain excluded when capture starts. Upgrade the phone and helper together; reload the upgraded Hermes plugin for already-running sessions.
* Enroll supported sessions already running on the Mac, preserve encryption keys across long resumes, and report capture problems instead of silently showing incomplete history.
* Keep command discovery moving when an earlier delivery acknowledgement fails. Receipt retries stay scoped to their server, account and machine, and a stale acknowledgement cannot erase a newer delivery result.

## 1.9.76 [#1976]

* Session history is on by default. A computer that never chose now syncs each session's conversation to your phone, redacted and encrypted on the computer. Turn it off on one computer with `npx pushary@latest transcripts off`. An owner or admin can turn it off for the whole workspace in Agent settings.
* A session that was already running when Pushary first sees it now syncs only its last 20 MB, and only what was written inside your plan's history window: 14 days, or 30 on Agent Pro, Team, Partner and Enterprise. It used to upload the whole session file, however old or large.
* The background service now reads each session file from where it stopped, instead of reading the whole file every three seconds.
* Mac app: a session that was already running when you sign in can sync its earlier conversation, inside the same limits, once the Mac app grants it. Turning history off and back on still syncs only what is written after you turn it on.

## 1.9.75 [#1975]

* Stream completed Claude display lines from directly started sessions through the existing encrypted transcript path.
* Share native and SDK preview retries, preserve newer replies when old batches arrive, and recover snapshots after receiver replacement.
* Include durable idle instruction delivery and recovery for the compatible Claude, Codex and Hermes controllers merged in #2251.

## 1.9.74 [#1974]

Not published to npm. These changes first shipped in 1.9.75.

* Improve instruction delivery to supported running Claude Code, Codex and Hermes sessions on macOS, including recovery after lost acknowledgements and receiver restarts. Uncertain delivery stays pending instead of reporting success or submitting the instruction again.
* Keep instructions bound to the intended session and acknowledge delivery only after the required hook or native receipt.
* Continue CLI setup automatically after successful phone pairing.
* Add durable receipt recovery for the qualified Hermes development build. Its upstream fixes are awaiting release; other Hermes builds keep their existing compatibility limits. Native delivery on Linux and Windows remains unqualified.

## 1.9.73 [#1973]

* Claude Code: an instruction from your phone or the Mac app that arrives as a session finishes its turn no longer shows in the terminal as "Stop hook blocking error". On Claude Code 2.1.163 and later Pushary hands it to Claude as context, and the turn carries on. On older versions, or when Pushary cannot read the session's version, it is still the reason the turn continues, which every version reads. Pushary reads the version from the file Claude Code keeps for the running session.
* Codex, Gemini CLI, Qwen Code, CodeBuddy, Qoder and Droid: a message from your phone that Pushary had already saved on your computer is no longer marked delivered when the session ends its turn. These agents cannot be handed a message at that point, so it now waits for the next tool call or prompt.
* Transcript capture no longer uploads the request snapshots that Claude Code 2.1.300 and later write into the session file. They were more than half of what was uploaded, and the phone never showed them.

## 1.9.72 [#1972]

* Phone instructions now record a dispatch receipt before Claude, Codex or Gemini receives them. Provider acknowledgements confirm delivery; an interrupted, unconfirmed instruction is reported as uncertain instead of automatically running again. Delivery confirms receipt, not task completion.
* Claude phone sessions can recover a lost acknowledgement from matching native history. Idle follow-up messages and transcript updates use the existing remote controllers.
* Older polling, terminal delivery and acknowledgement formats remain supported by the updated backend. Update the backend before these controllers; they refuse to execute when dispatch persistence is unavailable.

## 1.9.71 [#1971]

* Codex in Full access: a call to an app you connected in ChatGPT or Codex that only reads, such as searching Gmail, listing GitHub issues or opening a Notion page, no longer asks you. Codex runs those calls without asking in Full access, and Pushary now does the same instead of holding each one for your phone and refusing it when nobody answered. With Alert only as your standing mode, these reads no longer send an update either.
* These still ask: calls that change something, such as creating a pull request, updating a spreadsheet or sending an email; reads whose name points at a secret, such as a password, token, key, environment variables or a recovery code; a read whose input names a web address, sets an HTTP method that writes such as POST or DELETE, carries a SQL statement that changes data in a form prose does not take, or a GraphQL mutation; any call to a database, warehouse or BI app; a read outside the scope you agreed; any call while a mode you set for a limited time is on; any call a rule you wrote covers; and every MCP server that is not a ChatGPT connected app.
* "Allow for this session" on an MCP read now stops covering a call whose input names a web address or asks to change something, the same way it never covers a risky shell command.

## 1.9.70 [#1970]

* Hermes: the plugin (0.8.1) no longer sends "Tool error in Hermes" to your phone each time a tool call fails. Hermes counts any command that exits non-zero as a failed tool call, so a `grep` that finds nothing or a test run that fails on purpose became a high-urgency push, up to three per Hermes session, and Hermes recovers from those on its own.
* When Hermes marks a turn as failed, the push for that turn now reads "Hermes run failed" with the reason Hermes gives, instead of "Hermes finished", and the session keeps the reason. It is the same push that ends every turn and follows your updates setting, so a scheduled job that keeps failing sends no more pushes than before. A provider error that stops Hermes before it finishes the turn, such as a rejected API key, still sends nothing. Hermes redacts the reason before it leaves your computer.
* The daily update and `pushary upgrade` replace a plugin folder that setup installed. Run `hermes gateway restart` to load the new copy. Pushary already drops the old copy's tool-error reports without a push, so they stop reaching your phone before you restart.

## 1.9.69 [#1969]

* fx: upgrade and the daily update also switch a `pushary` server written as `"type": "streamable-http"`, which fx reads as HTTP. An entry with no `type` is no longer taken for an HTTP server, because fx runs it as a local process.
* fx: the switch leaves a `pushary` entry that signs in with a different key than this machine's, in its URL, a header or another environment variable, so fx never moves to another workspace without you choosing it. It also leaves a scoped connector URL alone. Upgrade says why, and to run `npx pushary@latest setup --agents fx`.
* fx: when `~/.fx/mcp.json` cannot be written, upgrade keeps the entry, says so, and finishes. 1.9.68 failed the upgrade instead.
* `pushary doctor` says to run `npx pushary@latest setup --agents fx` for an fx HTTP entry, because `upgrade` changes nothing once you are on the latest version. Doctor names other Pushary HTTP servers in fx whatever state the `pushary` entry is in.

## 1.9.68 [#1968]

* fx: `pushary upgrade` switches a `pushary` server you added to `~/.fx/mcp.json` by hand as an HTTP server (`https://pushary.com/api/mcp/mcp`) to the local bridge that setup writes. fx's MCP-v2 engine (`FX_MCP_ENGINE=v2`) keeps that HTTP connection open between calls. Pushary's host closes a connection idle for about six minutes, and fx sends the next call on the closed connection. That call never reached Pushary, and fx reported "the server went away. The tool may have run." The bridge opens a new connection when it needs one, so the first call after an idle stretch arrives. Your other fx servers, your permission rules and your question settings stay as they are. Restart fx, or run `/mcp reload`, after the upgrade.
* The daily update makes the same switch. Neither switches when no Pushary key can be read on the machine, or when the bridge is not installed globally, because fx would then lose Pushary altogether. `pushary upgrade` says which, and to run `npx pushary@latest setup --agents fx`.
* Setup, upgrade and `pushary doctor` name any other fx server that reaches Pushary over HTTP, under a name other than `pushary`, and say to remove it, so fx does not see Pushary's tools twice.

## 1.9.67 [#1967]

* Hermes: setup installs the Pushary plugin as a folder in `~/.hermes/plugins/pushary`, where Hermes keeps your own plugins, instead of pip-installing it into Hermes's old virtualenv. Hermes v0.21.6 and later run from a Python they manage and rebuild on every `hermes update`, which left the pip copy behind and silently unloaded Pushary. The folder survives updates. Setup turns the plugin on with `hermes plugins enable pushary` and `hermes config set`, and never restarts Hermes for you.
* `pushary upgrade` moves a Hermes setup from before this release over to the folder, removes the old pip copy Hermes would otherwise load, and tells you to run `hermes gateway restart`.
* Setup no longer turns off Hermes's `clarify` tool. While the plugin is loaded it sends Hermes's questions to your phone through `pushary_ask`; without the plugin Hermes asks in its own prompt. Setups from before this release get `clarify` back.
* `pushary doctor` reports Hermes as connected only when the running Hermes loaded the plugin, and says when Hermes needs a restart, runs an older copy, or has the plugin switched off. It no longer asks for the global package when Pushary for Mac saved the key.
* Setup finds the `hermes` command in `~/.local/bin` and Homebrew when it is not on your PATH, and follows Hermes profiles (`HERMES_HOME` and `active_profile`).
* `pushary clean` removes the plugin folder only if Pushary installed it, and leaves a Hermes that Pushary for Mac connected, and the key the app saved for it, to the app. Neither setup nor the Mac app writes an older plugin over a newer one.

## 1.9.66 [#1966]

* In Claude Code, an approval stays answerable from your phone and from the terminal at the same time, and whichever answers first wins. Before, Pushary held the call for its window (60 seconds by default) while the terminal showed only a spinner, then withdrew the phone question and left only the terminal. Now Claude Code shows its own prompt straight away, Pushary sends the same question to your phone, and the phone keeps it for up to 10 minutes. Answer at the terminal and Pushary withdraws the phone question. This applies in an interactive Claude Code session in default or accept-edits mode, when only Pushary's defaults ask about the call. In bypass mode, and in `claude -p` and other headless runs, there is no prompt to answer, so Pushary still holds the call as before.
* Claude Code always shows its prompt for these calls, even where its own allow rules, a "don't ask again" choice or accept-edits would have run them without asking.
* A phone-only rule that approves or denies after a set time still does that when nobody answers in time. Other rules, including the built-in ones, never decide a call nobody answered: the prompt stays open. If Pushary cannot reach your phone, the terminal prompt stays and you answer there.
* A rule you wrote, a preset you picked or a mode you switched to for now keeps the old behaviour, as you set it up. So does a Team approval route, which its approver answers, not the terminal.
* Setup, upgrade and the daily update add a proof of the 10 minute hold to the Claude Code permission hook. Until then, an older registration keeps the window your rule had before, with the terminal answerable from the start.
* With Pushary for Mac, approvals work as before for now.

## 1.9.65 [#1965]

* OpenCode now asks before shell commands, edits and web fetches, so those approvals reach Pushary. Out of the box OpenCode runs all three without asking anybody, and Pushary's plugin can only answer what OpenCode asks, so until now an OpenCode set up by Pushary approved nothing. Setup sets `bash`, `edit` and `webfetch` to `ask` under `permission` in `opencode.json`, but only for a tool no rule of yours names. A rule for every tool (`"*"`), another name for the same tool (`shell`, `write`, `patch`), a switch under `tools`, a list of patterns and a single `permission` value all count as yours and stay as they are. Pushary's rules go before yours, and OpenCode follows the last rule that matches, so yours still decide.
* `pushary upgrade` and the daily update add the same rules to an OpenCode Pushary already set up, again only where you have set nothing, and list them as approval rules. They create no `opencode.json` and leave one they cannot read untouched.
* Setup and `pushary doctor` say which of the three OpenCode would still run without asking, and whether that is because no rule names it or because a rule of yours allows it. Doctor reports this as a warning, so it does not fail `pushary doctor`.
* `pushary clean` and `pushary disconnect opencode` leave these rules in place, because a rule may be one you set yourself. OpenCode then keeps asking in its own prompt.
* Pushary for Mac does not add these rules yet, and setup and upgrade leave an OpenCode the app set up to the app. On such a Mac, add `"bash": "ask"`, `"edit": "ask"` and `"webfetch": "ask"` under `permission` in `opencode.json` yourself.

## 1.9.64 [#1964]

* Setup can connect Cline. Pick Cline, or run `npx pushary@latest setup --agents cline`. Setup adds the Pushary server, with your key, to `~/.cline/data/settings/cline_mcp_settings.json`, the file Cline 4 reads for both the VS Code extension and the Cline CLI. It honours `CLINE_DIR`, `CLINE_DATA_DIR` and `CLINE_MCP_SETTINGS_PATH` as Cline does, keeps every other server in the file, and waits for Cline's own lock on that file so it never writes over a change Cline is making. A file Cline cannot read either is left untouched.
* Setup also writes `~/.cline/rules/pushary.md`, a global rule that tells Cline to ask through Pushary when you may be away, because Cline's own question tool waits in VS Code, and to tell you when a task of several steps finishes.
* Cline's own approval prompts stay in VS Code; Pushary cannot answer them. Setup says to reload VS Code, and that ticking Use MCP servers in Cline's Auto-approve menu lets Pushary calls run without a click, for every MCP server Cline has, not only Pushary.
* Running setup again keeps what you set on the Pushary server in Cline, such as its timeout, auto-approve list and extra headers, and switches it back on. A pushary server that reaches Pushary through a local command such as `mcp-remote` is replaced with the direct connection, and the command's own settings go with it. Setup leaves a server someone else named pushary untouched and says so.
* `pushary upgrade` and the daily update replace only the key in Cline's settings after it changes, and refresh the rule. A server you switched off stays off. An entry that signs in through Cline, reads the key from an environment variable, or runs a local command such as `mcp-remote` is left as it is; setup replaces the last kind. On a computer without Cline they create nothing.
* `pushary doctor` checks Cline's entry, says when its key is not the one hooks use, when the server is switched off, and when another server already has the name pushary. A key kept in a variable is reported as one doctor cannot check, not as a stale key.
* `pushary disconnect cline` and `pushary clean` remove the Pushary server and the rule, and leave a server someone else named pushary. Like setup, they write the settings file readable only by you; Cline's own saves to that file do not keep it that way. If Cline holds the file locked, the file cannot be written, or it cannot be read while it may still hold Pushary, clean finishes its other steps and reports Cline as left behind, and disconnect exits with an error.
* Setup warns when Cline has another server pointing at Pushary, so Cline does not see Pushary's tools twice.

## 1.9.63 [#1963]

* `pushary transcripts on` and `pushary transcripts off` turn encrypted transcript sync on or off for this machine, so your phone can show the conversation of a session instead of only its summary. Only that one setting in `~/.pushary/config.json` changes; the key and every other setting stay as they are.
* Codex and Gemini sessions already running from your phone keep syncing until they end, and `off` says so.
* Pushary for Mac keeps its own switch for the sessions it runs. `off` says when the app still saves history, and `on` says when the app is not saving them.
* When `PUSHARY_TRANSCRIPTS` in the shell says the opposite, the command says that it overrides the saved choice. A config file it cannot read or that does not hold valid settings is left untouched, and the command says which.
* `pushary login` now saves the same transcript choice as `pushary setup` when it saves a key: `PUSHARY_TRANSCRIPTS` when set, else the choice already on this machine, else on, with the same notice. Before, a machine signed in only through `pushary login` never synced transcripts. Running login again while the saved key still works changes nothing.
* The notice now names `pushary transcripts off` as the way to turn sync off.

## 1.9.62 [#1962]

* In Cursor, each shell command and file change reaches your phone once. Cursor also runs Claude Code's hooks, so with Pushary's Cursor gate installed every gated call was asked about twice, once by each hook. The Claude Code hook now leaves a call from Cursor to the Cursor gate when `~/.cursor/hooks.json` registers that gate for that kind of call and the gate can answer it: its script is present and new enough to handle that kind of call, or the Pushary app is installed. Anything the Cursor gate does not cover is still asked about by the Claude Code hook. Commands the Cursor gate lets run without asking, such as ones that only read, no longer reach your phone through the Claude Code hook. Pushary for Mac was never affected: it does not ask about the calls Cursor passes to Claude Code's hooks.
* When a session already has as many open questions as Pushary allows, a new approval is never approved and nobody is asked again. Before, the hook stopped the agent and told it to retry, and every retry was refused again. Now the call goes to a prompt only where one is sure to follow: Claude Code's own prompt or permission dialog, the prompt of an agent that runs Claude Code's hooks and has one of its own, such as Grok, and Codex's own confirmation for a call Codex itself asked about. Everywhere else it is refused, with a message that says why: under a rule that refuses when nobody answers, in Codex before a tool runs, in Gemini CLI and OpenCode, in Antigravity CLI, in sessions started from your phone, and for a call from Cursor, because Cursor does not hold a call for a prompt. Gemini CLI under When I'm out hands the call to Gemini, as it did before. A question your agent asks you ends as an unanswered question, so its own picker, plan dialog or MCP form shows.

## 1.9.61 [#1961]

* Pushary for Mac can connect Codex through its own helper, so Codex follows the account signed in to the app instead of a copied key that sign-out revokes. Setup, upgrade and doctor now recognize that entry. When setup or upgrade handles Codex's hooks itself, with `--take-over-hooks` or because the app is gone, it moves Codex's MCP to this CLI's account too, instead of leaving Codex on the Mac's account or on a helper that cannot start.
* That move also replaces a Codex configuration an older CLI could leave behind, where the Pushary entry held both the Mac helper's `command` and a `url`. Codex refuses to load any configuration with that mix, so Codex would not start at all. Any other Pushary entry with a `command`, including the helper with `args`, `env` or extra settings, is now left unchanged instead of getting a `url` beside it. An upgrade that has a key to write then leaves Codex's hooks unchanged too.
* When setup or a manual `pushary upgrade` moves an enabled Codex entry off the Mac helper, it asks you to fully quit and reopen Codex, because a running Codex keeps the connection it started with.

## 1.9.60 [#1960]

* Ships the CLI audit fixes merged after 1.9.59. `pushary mode terminal_only --for=30m` now expires after 30 minutes, just like `--for 30m`, instead of making the mode permanent.
* Setup, repair and disconnect respect the active Claude configuration directory. Hook commands safely quote paths containing apostrophes, dollar signs or shell substitutions.
* Commands reject unsupported preview flags and conflicting or surplus arguments before changing configuration. Transcript recovery works through both command entrypoints, and settings requests have a 15-second deadline with validated responses.
* JSON failures carry the same exit code as the process. Unexpected hook failures report a stable error code while preserving native fallback, and transient error reports get one bounded retry. Network errors and support bundles redact proxy credentials.

## 1.9.59 [#1959]

* Codex app cards now also carry three questions from Codex's browser: access to a site, a download and an upload. They used to show only in Codex, because the browser raises them itself and no hook sees them. With the switch on, each reaches Pushary as a yes or no question that names the site, and the first answer wins. A download or upload question carries the address up to the end of its path. Nothing after a `?` or `#` is in that question, and the address ends in … when something was left out; the path itself is sent.
* For a download or an upload, Yes allows that one transfer. For a site, Yes allows the site for the rest of the conversation, or for the turn if Codex is set to ask each turn, and No blocks it for the conversation, because that is what Codex does with the answer its own Allow button sends. The question's details say which. Pushary never sends "always", "for this site" or "for all sites"; those stay in Codex.
* `pushary codex --app-cards on`, `pushary codex --desktop` and the command's help now say that the browser's questions are carried too.
* Other Browser use questions stay in Codex for now: Developer Tools access, browsing history, verification codes and sign-in.

## 1.9.58 [#1958]

* `pushary clean` no longer removes the Codex app cards launcher when it could not turn the switch off. It keeps the folder and prints the reason. Before, a failed turn-off could leave the Codex app starting through a launcher that was gone, and Codex would not start its engine until the next logout. The same now holds when the setting that starts the Codex app cannot be read while a launcher or login item is on disk: clean and `pushary codex --app-cards off` change nothing and say so, where they used to read it as not set.
* `pushary clean` leaves the launcher folder to the step that turns the switch off. Its last sweep of `~/.pushary` used to remove the folder a second time, which could delete a launcher the running Mac app had just written back.
* With the switch turned on from the command, cards keep reaching Pushary after the CLI updates itself while Codex is open. The pass-through loaded part of its code at the first card, and an update replaces those files, so the first card after an update stayed in Codex. It now loads that code when it starts.
* `pushary codex --app-cards status --json` also reports where the launcher is, whether the launcher and login item are what this version writes, and whether a switch that is off left a launch setting behind. The Pushary Mac app uses these to rewrite files an older version wrote and to repair a launcher that was deleted.
* Setup no longer says phone-start is "not running" when its background service is running and only the check fell short. That covers a service that started but was not verified in time, and an older service that could not be replaced and still runs. Setup now says the service is running but this run could not verify it, and points to `pushary doctor`. When the service could not be stopped or removed, setup says that, makes no claim about whether it runs, and no longer offers `pushary daemon install` for it.
* `pushary upgrade` and the daily automatic update no longer fail when a phone-start service that Pushary started on its own is running but not verified in time, or does not come up on a computer that had no service before. `pushary upgrade` prints the line setup prints; the daily update writes it to its log. Since 1.9.50 setup treated this as a note while the update still exited 1 and kept retrying. A service that was running before the update and did not come back still fails the update, and the update tries again to bring it back: the daily update after 5 minutes, an hour, then daily, where automatic updates run, and `pushary upgrade` each time you run it. It stops trying when the service runs again, when phone-start is turned off, or when this computer can no longer run phone-start. Where setup never recorded a phone-start choice, because the key came from `pushary login` or the Mac app, it also stops when the service is no longer installed. One case is not tried again: an upgrade started with `pushary upgrade` by an installed version older than this one, which keeps no record to try again from. `npx pushary@latest upgrade` and the daily update always keep one. Phone-start you asked for with `--control on` is retried the same way.
* `pushary upgrade` now remembers an upgrade whose last step, refreshing the agent configuration, did not finish. Running `pushary upgrade` again finishes it. This holds when the upgrade is started by this version or a later one, which `npx pushary@latest upgrade` always is. Before, the first run said to run it again and the second run answered "Already on the latest version" and did nothing. A last step that needs a change only you can make is recorded as waiting on you, so the daily update leaves it alone. `pushary doctor` shows these under "Last update check" (it said "Last automatic update check", which a manual upgrade is not), and a later upgrade that finishes replaces the record.
* When phone-start you asked for with `--control on` started but could not be verified in time, `pushary upgrade` says so and points to `pushary doctor`. It used to say the service did not start. With `--control on` on a computer that cannot run phone-start, it no longer says to run `pushary daemon install`, which could not work there.
* When an instruction file is left alone during an update, the message no longer says to run `pushary upgrade` again. That did nothing while the installed version was current. It now says the next update refreshes the file once it is fixed.

## 1.9.57 [#1957]

* Codex questions you answer by typing now reach Pushary. When Codex asks something with no suggested answers, the hook used to leave it in Codex, so it never showed in the notch or on your phone. It now arrives as a question with a text field, and what you type goes back to Codex in place of its card, word for word. One exception: an answer that is only the word "defer" hands the question back, as it does everywhere else, and Codex shows its own card.
* Several questions in one call are still asked one after the other. A typed question and a question with choices can sit in the same call.
* Nothing else has to update first. A typed question is sent as the same text question `ask_user` has always sent, so every released phone app, Mac app, Slack message and decision page shows it.
* A blank answer is not passed on. When the answer is blank, nobody answers, or you hand the question back, Codex shows its own card. A question with exactly one choice, more than four, or a secret still stays in Codex.

## 1.9.56 [#1956]

* Setup, doctor, upgrade and the background service now find Claude Code in its own install folder when the `claude` command is not on PATH or in npm's global folder: `~/.local/bin/claude` on macOS and Linux, `.local\bin\claude.exe` under the user profile on Windows. The official Windows installer leaves that folder off PATH and asks the person to add it by hand, so `setup --control on` closed with phone-start unsupported on a computer that had Claude Code installed. Phone-start counts the program only when the home folder is an absolute path and, on macOS and Linux, the file can be run.
* On such a computer a default setup now installs phone-start, as it already does where `claude` is on PATH. `pushary upgrade` does the same when the stored mode is `auto`, and on macOS the automatic update runs that step in the background. As on any computer where phone-start is on, `pushary upgrade` exits 1 when the background service does not come up. With stored mode `auto`, `pushary doctor` reports the background service as missing there until setup or upgrade has run on this version. `setup --control off` keeps phone-start off.
* A session started from the phone launches Claude Code from that folder too. Before this release the launcher looked only on PATH, so such a computer could not have started one.
* Setup reads the Claude Code version from that folder as well, so on macOS and Linux it registers the same hook events as when the folder is on PATH. On Windows the program's file name carries no version, so nothing changes there.
* When the Claude Code program's file name carries no version, Pushary reads the version from a `package.json` above the program. Only a `package.json` that names Claude Code, or one of its per-platform packages, now counts. Before this release any project's `package.json` there counted, the home folder's included. A version below 1.0.0 then left Claude Code with no Pushary hooks after setup, `pushary upgrade` or the next session start, and a version from 2.0.0 registered events an older Claude Code does not know.
* When required phone-start has no agent it can start, the closing steps say what it needs and where the commands are looked for. Setup's "Phone-start was required" line now uses the wording doctor uses. `pushary claude` no longer names PATH as the only place it looked when it finds no program.
* On Windows, setup's agent detection now names the Claude Code program as what it found. Before, it looked for a file without the `.exe` ending and could only see the `.claude` folder.
* Turning Codex app cards off now stops forwarding cards even if the installation receipt is missing or unreadable. The retained launcher recovers the engine path from its own script so an already-open Codex can keep running.
* Refreshing agent instructions preserves existing file permissions, including shared files reached through a symlink, even when the updater's umask is more restrictive.

## 1.9.55 [#1955]

* The setup test now says how to answer it. When the Pushary phone app is connected, setup prints the step for that phone: "Press and hold the notification, then tap Approve." on iPhone, "Expand the notification, then tap Approve." on Android. It then waits with "Waiting for your answer". The buttons on the notification answer the question on every version of the app; on Android the button asks you to unlock the phone first. A plain tap opens the app, and during the app's first run that showed "Connect your computer" in place of the question, so the test went unanswered.
* `pushary doctor --roundtrip` prints the same step, so the command setup points to no longer gives different advice.
* When nothing comes back, setup says to send another test and then gives the step for that phone, in that order, because the first notification has been withdrawn by then. A browser connection keeps the earlier wording.
* The test question no longer says "Tap Yes or No". The buttons are named Approve and Deny in the phone app and Yes and No elsewhere, so it now reads "Answer either way".
* A setup test stopped with Ctrl-C while it waits for the answer is now reported. Setup records the interrupt, the step it stopped at (`answer-test`), the agents it had configured and that the notification was delivered, before it exits. `--json` prints its one result object for that exit too. Before this release that exit reported nothing, so a test somebody gave up on left no record.

## 1.9.54 [#1954]

* For a switch the Pushary Mac app turns on, the login item that keeps Codex app cards on after a restart now runs Pushary's own program and not a shell line, so macOS treats it as part of Pushary and not as a separate `sh` item. A switch turned on with `pushary codex --app-cards on` keeps the login item it has, unchanged.

## 1.9.53 [#1953]

* `pushary codex --app-cards status --json` prints the switch's state as one line of JSON for a program to read: the state, the Codex app found on this Mac, whether the Mac app turned the switch on, and whether it was turned off on purpose. The Pushary Mac app uses it for its new Settings switch, which is on by default there.
* `pushary codex --app-cards off` is remembered. The Pushary Mac app turns the switch on by itself, and it leaves alone a switch you turned off with this command until you turn it on again. `pushary clean` keeps that record while the Mac app stays installed.
* The login item that keeps Codex app cards on after a restart now also checks that every file of Pushary's own program is still there. If Pushary was removed without turning the switch off, Codex starts the ordinary way from the next login. An existing login item gets the check the next time the switch is turned on.

## 1.9.52 [#1952]

* `pushary upgrade` and the daily automatic update now refresh the Pushary instructions in each agent's instruction file: Codex, Gemini CLI, OpenCode, fx, Qwen Code, CodeBuddy and Grok. Before this release only `setup` wrote them, so a machine set up before 1.9.43 kept the old text after every update and its agents were never told about reminders. In fx a plain "remind me in 2 minutes" could fall back to a sleep timer that stops when fx closes.
* The refresh only replaces a Pushary block that is already there. It never adds one to a file that has none, never creates a file, and keeps the text around the block byte for byte, Windows line endings included. The file is replaced in one step, so a full disk or a stopped update cannot leave half a file.
* It leaves a file alone and names it when the file is read-only, is not UTF-8 text, or holds Pushary markers that do not form exactly one block. The upgrade still finishes. Fix the file and run `pushary upgrade` again.
* fx is now part of the refresh. Its instructions are refreshed when the Pushary server entry in `~/.fx/mcp.json` is the CLI's. The server entry and `~/.fx/settings.json` are not touched.
* fx starts the daily update check. Each time fx starts the Pushary server, Pushary checks at most once a day for a newer version, the same way a Claude Code, Codex or Gemini session start does. A machine that only uses fx used to stay on the version it was set up with.
* Agents the Pushary Mac app owns are left alone, fx included, and reported as kept.
* `pushary upgrade` on a machine with no global install now names fx and the command that updates it.

## 1.9.51 [#1951]

* `pushary codex --desktop` now does the one thing it was built for. When the Codex app shows "Allow Computer Use to use Calculator?", you get one Pushary question, "Allow Codex to use Calculator for this conversation?". Yes allows that app for that conversation, No denies it, and answering in Codex first withdraws the question. Before this release the launch never forwarded anything: it expected the Codex app to start its engine in a way the app does not, and it did not recognise the request the app really sends.
* Pushary asks only when the card comes from Codex's own Computer Use and carries exactly the words Codex shows. A card another tool raises, or one worded differently, stays in Codex. It waits ten minutes for an answer, then withdraws the question.
* The launch no longer touches commands or file edits in the Codex app. Your hooks already handle those, so nothing is asked twice.
* The launch works with any Codex app version that keeps its engine in the known place, instead of one exact version. A request Pushary does not recognise stays in Codex.
* New, off by default: `pushary codex --app-cards on` makes the Codex app start through the same pass-through every time you open it, including after a restart, with no terminal to keep open. `pushary codex --app-cards off` undoes it and `status` says where it stands, including when Pushary or the Codex engine is no longer where the launcher expects. It writes a launcher under `~/.pushary/codex-app`, a login item, and the `CODEX_CLI_PATH` setting for your login session, and leaves that setting alone if another program already owns it. `off` replaces the launcher with one that only runs Codex's engine and leaves that file in place, because the Codex app records its path in `~/.codex/config.toml` and an open Codex keeps using it; `pushary clean` removes it, after which Codex should be reopened.
* The launcher steps aside by itself: it hands every engine command except the app's own protocol straight to Codex's engine, starts the engine itself when Pushary is missing, broken, never starts it, or the launcher cannot write beside itself, and turns its own setting off if a Codex update moves the engine. If the launcher is stopped, Pushary stops the engine within a few seconds.
* The pass-through holds at most 64 KiB of the app's input and inspects at most 256 KiB of a line from the engine, loads the code that talks to Pushary only when a card appears, does nothing while idle except check every two seconds that its launcher is still running, lets the engine finish its own shutdown when Codex quits, and keeps copying if anything in it fails. The first time Computer Use asks in a way this version does not know, it says so once in Codex's own log.
* Setup on a Mac that has the Codex app and no Codex CLI: setup never takes Pushary's own launcher for Codex, and it finds the app's engine where the current Codex app keeps it when Codex's settings file does not name one. Before, the first would have skipped native hooks and the second reported Codex as not found. Correction: this entry first said such a Mac got no hooks at all since the Codex app changed its layout. That was wrong. When Codex's settings file names the app's own engine, as it does after Codex has started normally, setup already found it and installed hooks.
* `pushary codex` is experimental and no longer appears in `pushary --help`. It still runs when typed, and `pushary codex --help` describes it.

## 1.9.50 [#1950]

* Setup no longer reports a problem when it tried to install phone-start on its own and the background service did not start. The run closes on what the approval check found, and the closing notes say phone-start is not running. `--control on` still fails the run when phone-start cannot be made ready.

## 1.9.49 [#1949]

* A program at a nested path under a system folder, such as `/opt/homebrew/bin/tools/cat` or `/usr/local/bin/x/zsh`, is no longer treated as the system tool of the same name. It asks a person where it used to run as a read, and `pushary codex` no longer reads a script out of a shell at such a path. Programs directly inside `/bin`, `/usr/bin`, `/usr/local/bin` and `/opt/homebrew/bin` are judged as before. The `pushary codex` half needs the matching server.
* `pushary codex`: a question or form Pushary leaves with the terminal, in Terminal mode or because you are at the keyboard, is no longer reported as a failure in the Codex screen. Neither is a form you answer in the terminal before the phone does.
* Recorded late, shipped in 1.9.47: `pushary clean --everything` also removes stale app registrations, leaked test preferences, the app's per-user cache folders and crash reporter entries, and `clean` and `disconnect` delete the Grok hook file once nothing else is left in it.
* Recorded late, shipped in 1.9.45: a question Codex asks in a `pushary codex` session reaches your phone as well as the terminal.

## 1.9.48 [#1948]

* When `--control on` cannot work because this computer has no `claude`, `codex` or `gemini` command on PATH, or no background service manager, setup says which one is missing instead of suggesting `pushary daemon install`.
* The setup report records which of the two was missing, so a phone-start failure on Windows can be told apart from one on a headless session.

## 1.9.47 [#1947]

* `pushary codex`: when Codex asks to approve a call Pushary already allows (your rules, a preset, or a read-only command), it is approved for you once, as the Codex hook already does. A file change is never approved this way, and neither is a request Codex flags as needing a person. The kill switch and deny rules are unchanged. This needs the matching server.
* `pushary codex`: a command Codex runs through a login shell (`/bin/zsh -lc 'git push origin main'`) is asked about and matched against your rules as the command itself, so a rule such as `Bash(git push*)` applies to it. This needs the matching server.
* `pushary codex`: an approval Pushary hands back to Codex's own prompt is no longer reported as a failure in the Codex screen.
* `pushary codex --desktop` no longer throws while stopping when the Codex engine's processes have exited but are not yet reaped, which macOS reports as a permission error.

## 1.9.46 [#1946]

* A command that feeds text to a database client or a shell through a pipe, a heredoc or a here-string is judged together with that text again. Under the Autonomous preset or a rule that allows everything, `echo "DROP TABLE users;" | psql app` asks a person, as it did before 1.9.39. A pipeline that only reads, such as `npm test | grep release`, still runs unasked.

## 1.9.45 [#1945]

* Add an opt-in experimental Codex Desktop launch with `pushary codex --desktop`. Quit Desktop first; the bridge uses its supported bundled engine and forwards supported native permissions through Pushary.
* Computer Use approvals preserve conversation scope and warnings. Native prompts remain available when forwarding is unavailable, and competing phone/local answers are resolved once.
* Desktop forwarding currently supports bundled engine 0.162.0-alpha.2 on macOS. It uses an undocumented launch override; real Calculator-to-phone acceptance is still pending. Ordinary setup does not enable it.

## 1.9.44 [#1944]

* Start a managed Codex terminal session with `pushary codex` and route supported command, file-change, and MCP permissions through Pushary. The native terminal remains available for unsupported requests.
* Preserve repository-specific deny and routing rules, cancel stale questions across delayed or lost responses, and stop owned session processes on shutdown. Existing Codex desktop chats are not attached by this feature.

## 1.9.43 [#1943]

* Agent and fx setup guidance uses Pushary’s durable personal reminders, which persist after the agent exits and deliver privately to their creator.

## 1.9.42 [#1942]

* Complete Mac cleanup removes the Partner enrollment and device-key slots introduced by the native Partner flow, alongside existing session state.
* Bundled agent guidance preserves native Mac setup, explains store-specific checkout terms and returning to the pairing link after installation or restart, and distinguishes a synthetic question test from a real hook approval check.

## 1.9.41 [#1941]

* Personal Codex sessions reject an invalid question set before asking anything on your phone. Malformed or repeated choices no longer disappear, and ordinary free-text replies, cancellation and host deadlines keep their existing behavior.

## 1.9.40 [#1940]

* Personal Codex question replies bind to the original connection and request. A saved answer is claimed once; missing delivery confirmation never triggers automatic replay.
* With the matching server, blocked-action answers and their short-lived grants commit together, and a Stop prevents later claims. Question answer time remains separate from this grant window.
* Phone, Mac and browser inboxes read every authorized question page. Saved answers and unconfirmed delivery have separate messages; neither claims an action ran.

## 1.9.39 [#1939]

* When away recognizes destructive Codex commands behind Git options and command wrappers, and recursive PowerShell deletions.
* Malformed Codex question choices stay in Codex instead of appearing in Pushary with choices silently removed.

## 1.9.38 [#1938]

* Owned Codex child questions reach the long-wait bridge instead of being asked first by a short-lived native hook. The matching Mac helper hands these questions to the CLI; kill, deny and command-permission checks still apply.
* Questions in the personal Codex child bridge keep waiting until answered or cancelled when Codex supplies no deadline. A short poll or temporary network failure no longer cancels the question.
* A cancelled request or an explicit Codex deadline still stops the wait and rejects a late answer. Native permission hooks and recovery after closing Codex keep their existing limits.
* With the updated Pushary server, ordinary MCP questions remain available after the cache clears and can receive one reminder after ten minutes. This saves the answer; it does not promise that a closed agent will restart.

## 1.9.37 [#1937]

* Codex questions reach Pushary. When Codex asks you something with its question card (`request_user_input`), the question and its choices go to your phone or the Mac notch, and your answer goes back to Codex in place of the card. A question with no choices, one choice, more than four, or a secret stays in Codex, and so does one nobody answers or Pushary cannot reach. Setup and upgrade widen the Codex `PreToolUse` matcher to include both question tools.
* When away now asks about a destructive Codex command (such as `rm -rf`, a force push, `git reset --hard` or `git clean`) or a patch that deletes a file, because Codex can run those without a prompt of its own. The question goes to your phone when you are away from the keyboard; at the keyboard Codex carries on as before. A call nobody answers is refused.

## 1.9.36 [#1936]

* Connect Grok Build to Pushary with native hooks for tool approvals, session activity and subagent activity. Setup, doctor, upgrades and disconnect use Grok's configuration directory, including a custom `GROK_HOME`.
* Grok patch approvals inspect every affected path, including move destinations, and show the patch in the approval receipt. Existing kill, deny and scope rules apply to those calls.
* Cleanup reports malformed or unreadable agent configuration and preserves the file so it can be repaired.
* Grok's question and plan dialogs stay in Grok. Use Pushary's MCP tools for phone questions. Grok itself continues after a hook crash or timeout, so Pushary hooks do not replace Grok's native permission checks.

## 1.9.35 [#1935]

* When you run setup yourself in a terminal and your phone cannot get notifications yet, it no longer stops with exit code 6. It asks you to open the Pushary app and allow notifications, waits up to 10 minutes for your phone, then sends a test notification. Press Enter to skip the wait. Runs with `--yes`, `--agents` or `--json`, and computers with the Pushary Mac app, keep the single check.

## 1.9.34 [#1934]

* Live questions keep waiting when a tool poll ends; agent instructions no longer cancel them after one retry.
* Questions preserve every point up to 8,000 characters instead of being silently cut to 500. Notification previews stay short.

## 1.9.33 [#1933]

* Session history keeps saving a conversation when the history process is stopped during that conversation's first upload. It used to make a new encryption key on restart, which the server refused, and the rest of that conversation was never saved.
* When the server cannot take history uploads, retries wait up to 12 seconds instead of repeating every 3 seconds, and go back to every 3 seconds as soon as one is accepted.
* A finished session with nothing to save, or one another Pushary process is already saving, stops being watched. Before, it held one of the 32 history slots for up to two days.

## 1.9.32 [#1932]

* A paused session keeps asking about destructive PowerShell and Monitor commands, just as it does for Bash.
* SQLite bracket identifiers cannot hide a later write behind a comment marker. MySQL and MariaDB bracket syntax asks when the server's SQL mode is unknown; PostgreSQL and GoogleSQL array reads keep running.
* SQL writes next to quoted identifiers, such as `UPDATE[users]SET[x]=2`, ask even without spaces between the tokens.
* Commands beyond the remote API inspection limit ask for approval.

## 1.9.31 [#1931]

* SQL sent through `psql`, `mysql` and `mariadb` is now read the way the database reads it. These used to run under an approve rule and now ask: a write after a dollar quote with a non-ASCII tag, such as `psql -c 'SELECT $é$ -- $é$; UPDATE users SET x=1'`; a write after a carriage return that ends a `--` comment; and a write inside a MySQL `/*! ... */` or MariaDB `/*M! ... */` comment, which those clients run.
* `SELECT ... INTO` and a `LOCK` statement now count as writes and ask, as do `EXECUTE IMMEDIATE` and `PREPARE ... FROM`.
* A command after `bash -c` and its options is now seen, so a `Bash(git push:*)` deny rule now refuses `bash -c -x 'git push'`, `bash -c -- 'git push'` and `zsh -c -x 'git push'`, which used to run.
* `env` options are read the way GNU and macOS `env` read them, abbreviations included, so the same deny rule now refuses `env --spl='git push'`. When the two versions of `env` would run different commands, Pushary asks.
* Codex: `gh api -iXDELETE` and `gh api -iX DELETE` are read as DELETE requests and ask, instead of being passed back to Codex.
* A tool name that is not one concrete tool, such as `*`, can no longer be saved as an Always allow rule.
* History capture works when Claude Code or Codex keeps its files under a custom `CLAUDE_CONFIG_DIR` or `CODEX_HOME`.
* `pushary-mcp` tells Pushary which computer is asking, so the phone's Try it step checks the computer you chose.

## 1.9.30 [#1930]

* "Always allow PowerShell" and "Always allow Monitor" now ask about the same consequences "Always allow Bash" does. A Monitor command is judged exactly as the same Bash command. In PowerShell that includes `Remove-Item -Recurse`, `irm ... | iex`, a downloaded script then run, `Set-Content .env`, `Stop-Service`, `Format-Volume` and a recursive `Get-ChildItem` piped to `Remove-Item`. A plain `Remove-Item file.txt`, `git push`, `Stop-Process`, `-WhatIf` and every read such as `Get-ChildItem` keep running.
* A `*` approve rule no longer runs a destructive PowerShell or Monitor command, such as `Remove-Item -Recurse -Force ~`, `cmd /c rd /s` or `rm -rf ~`, without asking. It asks, as it already did for Bash.
* Codex: a call nobody answers is now refused instead of passed back to Codex, which ran calls it does not ask about itself. Only a rule you set to approve on timeout lets it run.
* A call refused because your phone approvals for a session are paused now says so, and tells you to tap Approve on the notification to resume. It used to say "No response within timeout".
* Codex: a GitHub, Stripe, AWS or Twilio write behind `caffeinate`, `stdbuf` or `flock` now asks, and `gh` asks about anything that is not a known read, such as `gh extension install`, `gh ssh-key add` or `gh label clone`. `gh pr co` now runs like `gh pr checkout`.
* Codex: a patch to a GitHub workflow or secrets file now asks however its path is capitalised, so `.GitHub/Workflows/ci.yml` no longer runs unasked.
* When two of your rules hold a call equally, Pushary now uses the one that refuses it if nobody answers, whatever order the rules are in.
* Antigravity CLI: input to a running command that is not text is now refused instead of shown as blank input.

## 1.9.29 [#1929]

* Codex: answering "Handle on your machine" now always refuses the call, and tells you to ask Codex to run it again while you are at your computer, or to run it yourself. In Codex's default modes the call used to pass back to Codex, and a call Codex does not ask about itself, such as a remote API write or a file deletion, could run without anyone approving it.
* In a session started from your phone, "Handle on your machine" now refuses the call with the same reason every agent without an approval prompt of its own gives.

## 1.9.28 [#1928]

* Antigravity CLI: text agy sends to a command it left running (`manage_task` with `send_input`) now goes through Pushary and is judged as the shell command it types, so your `Bash` rules and safe read-only commands apply to it. It used to run with nobody asked, because connecting agy turns off its own prompt. Sending blank input, such as pressing Enter, asks your phone. Listing, checking and stopping agy's own background tasks run without a question.
* Antigravity CLI: a call the hook cannot read (empty or malformed input, or a tool call with no name) is refused with a reason instead of running. So is every agy call while an admission rule, a wildcard included, has switched agy's approval hook off. Pushary's own tools still run.
* `pushary upgrade` and automatic updates now also refresh the hooks of Antigravity CLI, Qwen Code, CodeBuddy, Qoder, Droid and Devin when this CLI set them up, so a connection made on an older version picks up the current hook set without running setup again. Other entries in those files are left as they are.

## 1.9.27 [#1927]

* A `Bash(...)` deny or ask rule you write in Pushary now catches the command it names however it is spelled. With a `Bash(git push:*)` deny and a rule that otherwise allows Bash, these used to run and are now refused: `git -C . push`, `git -c x=y push`, `git --no-pager push`, `git --git-dir=.git push`, `GIT_DIR=.git git push`, `FOO=1 git push`, a push behind `env`, `nohup`, `time`, `nice`, `timeout 60`, `exec`, `command`, `builtin`, `xargs`, `sudo` or `arch -arm64`, `"git" push`, `\git push`, `/usr/bin/git push`, `git  push` with two spaces, `(git push)`, `{ git push; }`, `bash -c "git push"`, `sh -c 'git push'`, `eval git push`, a heredoc fed to `bash`, `find . -exec git push \;`, a push inside `if ...; then ...; fi`, and a push chained after a command Pushary could not split before, such as `x=$(git rev-parse HEAD) && git push`, `echo hi > out.txt && git push`, `npm test && git push $(git remote)`, or Claude Code's heredoc commit followed by `&& git push 2>&1 | tail -5`. An ask rule now asks for every one of these. The same holds for any rule, such as `Bash(npm publish:*)` or `Bash(rm:*)`.
* A command whose program Pushary cannot see, such as `$GIT push`, `"$(which git)" push`, `bash -c "$CMD"`, `eval "$(ssh-agent -s)"` or `cat script | bash`, is now refused when you have a deny rule for a Bash command, and asks when you have an ask rule. Every preset includes ask rules for destructive commands, so under the Autonomous preset such a command now asks instead of running.
* The read-only floor no longer approves a read that your deny rule names in another spelling. With a `Bash(cat:*)` deny, `"cat" .env`, `/bin/cat .env` and `c''at .env` were approved as reads. With `Bash(cat .env)`, so were `cat ./.env`, `cat '.env'` and `cat  .env`, and with `Bash(git log:*)`, so were `git  log`, `"git" log` and `git "log"`. They are now refused, and an ask rule asks for them.
* A rule that approves still covers only the command as written. `Bash(git commit:*)` does not start approving `env FOO=1 git commit` or `bash -c "git commit"`. A narrow ask rule that now catches a new spelling never weakens a broader deny: with a `Bash` deny and a `Bash(npm test:*)` ask, `FOO=1 npm test` is still refused.
* The `ask` and `deny` rules in your Claude Code settings read the same spellings. With `Bash` allowed and `Bash(git push:*)` denied there, Pushary used to step aside for `git -C . push` as a call Claude Code allows. It now handles that call under your Pushary rules.
* `pushary setup` keeps the whole pairing QR on screen for the whole wait on an 80x24 terminal. After 45 seconds the install hint, and after a minute the browser sign-in command, used to print as new lines under the code. Each one scrolled a top row of the code off the screen, so after a minute it no longer scanned. They now take turns with the minutes left on the waiting line itself. When setup's output is not a terminal, each still prints once on its own line. The install hint now says "scan the QR above" instead of "scan the code above" so it fits on one 80-column line.
* The background service now tells Pushary whether automatic updates can run on this computer, and if not, why: turned off, CI, Windows, Linux, or not a global install. It also sends the result and the time of the last update check, with no file paths or error text. Your agent overview uses it to show a computer that is stuck on an old version.
* The bundled Pushary skill now gives the When I'm out window as 20 seconds by default, which is what the built-in rules use. It said 10.

## 1.9.26 [#1926]

* `arch` is no longer approved as a read. On a Mac, `arch -arm64 <command>` runs the command after it, so `arch -arm64 git push --force` was approved without asking, even under a `Bash(git push:*)` deny rule. A command behind `arch` is now judged like the same command without it. Use `uname -m` to read the architecture; it is still approved as a read.
* Codex in any mode except full access now asks your phone before a command that changes something through GitHub, Stripe, AWS or Twilio, such as `gh pr comment`, `gh api -X DELETE`, `gh api ... -f field=value`, a GraphQL mutation, `stripe refunds create`, `aws lambda invoke`, `aws ses send-email`, an upload with `aws s3 cp` or `aws s3 sync`, or `twilio api:core:messages:create`. Since 1.9.15 these ran without a question whenever Codex did not raise one of its own, which is the case when its sandbox allows network access. Reads such as `gh pr view`, `gh api repos/...`, `stripe charges list`, `aws s3 ls` and `aws ec2 describe-instances` still run without asking.
* In the same modes Codex now also asks before a patch to a `.env` file, a credentials file or a GitHub Actions workflow. Codex applies an edit inside the project without asking, so these used to change with nothing shown. `.env.example` and other files under `.github` are not affected.

## 1.9.25 [#1925]

* "Always allow Bash in this workspace" and "Always allow Bash in this repository" now still ask about a command with a real consequence. That is running downloaded code (`curl ... | sh`, or a file downloaded and then run), a production deploy or migration (`vercel --prod`, `RAILS_ENV=production bin/rails db:migrate`), a schema push or reset (`prisma db push`, `prisma migrate reset`, `supabase db push`, `drizzle-kit push`), a SQL client that writes or runs a script file (`psql -c "UPDATE ..."`, `psql -f`, `psql < file`, `sqlite3 app.db < schema.sql`), `redis-cli FLUSHALL`, a cluster deploy (`kubectl apply`, `helm upgrade`), publishing (`docker push`, `npm publish`), `gh pr merge`, `gh repo delete`, `aws s3 sync --delete`, restarting, stopping or unloading a service (`systemctl restart`, `launchctl unload`), throwing away uncommitted changes (`git checkout <file>`, `git restore`, `git branch -D`), and writing or deleting a `.env` or secrets file. These used to run without a question. They are recognised behind wrappers such as `sudo`, `env`, `timeout` and `xargs`, behind global flags such as `git -C dir`, inside `if` and `for` blocks, and with output redirected to a log file.
* Under those rules a plain `git push`, `git push -u origin HEAD`, `git push --dry-run`, `git clean -n`, and an `rm`, `git rm` or `unlink` of a file keep running. Asking about every push and every removal under a rule that says always allow is too much. A force push, `rm -r` and `git clean -f` still ask, as before, and a force push now also asks when it is written as `git -C dir push --force`, `git push origin +main`, or a push that deletes or mirrors branches on the remote (`--delete`, `:branch`, `--mirror`, `--prune`).
* The same applies to a bare `Bash` approve rule written on the Policies page and to rules saved before this release. Presets and "Allow Bash for this session" keep their own rules. To let one of the held commands run anyway, add a specific rule such as `Bash(docker push:*)`.
* Claude Code's commit form, `git commit -m "$(cat <<'EOF' ... EOF)"`, is now read as a commit when every shell reads its message as plain text, including macOS `/bin/bash` 3.2. "Allow Bash for this session" asks about fewer commits, a `Bash(git commit:*)` rule now covers them, and a `&& git push` after one is seen, also by a `Bash(git push:*)` deny rule. A message with an unmatched `)`, an apostrophe, a backslash, a backtick, or a line that starts with the closing word such as `EOF`, is not read this way and asks as before.
* Production deploys and migrations, SQL that writes, runs a script file or comes from a variable or a pipe, `mongosh --eval`, cluster deploys and schema resets (`kubectl apply`, `helm upgrade`, `prisma db push`), `pg_restore --clean`, `mongorestore --drop`, `gh pr merge`, and publishing or deploying with `docker push`, `twine upload`, `cargo publish`, `npm unpublish`, `gh release create`, `pulumi up`, `cdk deploy`, `firebase deploy`, `fly deploy` or `wrangler deploy` now also ask under "Allow Bash for this session". These checks skip a command run with `--dry-run` or `--help`, but a command that says deploy, publish or release, such as `cargo publish --dry-run` or `firebase deploy --dry-run`, still asks, as it did before this release.

## 1.9.24 [#1924]

* Under When I'm out, a call nobody answers is refused for every agent with no approval prompt of its own (Antigravity CLI, Cursor file edits, sessions started from your phone), even when your rule approves on timeout. The 1.9.17 notes said this; only Codex did it. Under Every time a rule that approves on timeout still runs the call after its full wait.
* After three approvals nobody answered in a session, an Every time call whose rule approves on timeout keeps reaching your phone instead of running at once with nothing shown. Antigravity CLI sessions are no longer paused at all: agy sends nothing that could lift the pause, so every later call was refused until a new conversation.
* "Allow for this session" is offered for an MCP tool only when its name says it reads, such as `get_issue` or `list_files`. A grant cannot see the arguments of later calls, so a tool such as `query` or `create_issue` asks every time. A session grant already given for such a tool stops applying.
* `pushary sign-out --revoke` and `pushary clean --everything` revoke only a key this CLI created by browser sign-in or pairing. The Pushary Mac app's key, a key you pasted or passed with `--key`, and a key from an `export PUSHARY_API_KEY` line are removed from this computer and not revoked, because the Mac app or another machine may still use them; the output says so and links to the dashboard to revoke it there. Since 1.9.8 `sign-out --revoke` could revoke the Mac app's own key. A key saved before 1.9.24 has no record of how it was made, so it is removed and not revoked until your next sign-in records one.

## 1.9.23 [#1923]

* A `printf` whose format has a numeric conversion, such as `%d`, `%x` or `%f`, is no longer approved as a read unless every argument is a plain number. zsh, the default shell on a Mac, evaluates those arguments as arithmetic, and an argument such as `'PWD[$(command)]'` ran the command while Pushary approved it without asking. `printf '%s\n' text`, `printf hello` and `printf '%d\n' 42` are still approved as reads.
* Codex with its approval policy set to never: answering "Handle on your machine" on your phone now refuses the call. Codex has no prompt of its own there, so the call used to run, a destructive one included. With Codex's own prompts on, the call still goes to that prompt.
* Antigravity CLI: when your Pushary subscription has ended, a call Pushary would ask about is refused with a message that says so. Pushary is agy's only gate, and the call used to run with nothing asking. Renew, or run `pushary disconnect antigravity` to give approvals back to agy.

## 1.9.22 [#1922]

* Each approval Claude Code or Codex sends through Pushary now carries the approval mode the agent reported for the session, such as `default` or `bypassPermissions`, so Pushary can tell which mode an approval was asked in. It is recorded with the approval and never used to decide one. A mode that is empty or not text is left out, and a long one is cut to 64 characters.

## 1.9.21 [#1921]

* `pushary setup` records a key as the one Pushary for Mac is signed in with only when Pushary for Mac holds that same key. It used to record any key it reused from your agent settings that way, including one left behind by an earlier CLI sign-in. `pushary clean` never revokes the Mac app's key, so it skipped that leftover key and left it working. Now it revokes it, and still leaves the Mac app's own key alone.
* For the same reason, a leftover CLI key is no longer reported as "signed out on this Mac" when it stops working.
* A key recorded by an earlier version stays recorded until setup saves a different key.

## 1.9.20 [#1920]

* `pushary setup` calls a key found in your agent settings the Pushary for Mac key only when Pushary for Mac holds that same key. A key left behind by an earlier CLI sign-in is called a key found in your agent settings, also when Pushary for Mac is installed.
* On Windows, when npm cannot replace a file during the global install (EPERM), setup says to close other terminals or editors that use Node, then run setup again. It used to suggest an npm prefix change, which does not help when another program has the file open. EACCES, and EPERM on macOS and Linux, keep the npm prefix advice.
* The pairing screen prints the fingerprint directly under the QR code, above the waiting line, so the QR code, the fingerprint and the waiting line all fit an 80x24 terminal. The fingerprint used to sit above the QR code and scroll off.
* `Wrong account? Run npx pushary@latest setup --connect app` is printed only where that command can pair: not in CI, and not with `--skip-phone` or `--connect none`. On an inactive plan it is printed once, next to the account with no plan, instead of twice.

## 1.9.19 [#1919]

* When nobody has answered the last 3 approvals in one agent session, Pushary stops sending that session's approvals to your phone. Each further call ends at once, exactly as it would have if nobody had answered it for the whole wait: under When I'm out Claude Code asks in its own prompt, a rule that refuses on timeout refuses it, a rule that approves on timeout runs it at once with nobody asked, and Codex set to never ask for approval refuses it. Nothing is sent, and the paused approval does not appear on your phone or in the Mac app. A command that deletes, rewrites history or reaches the network, such as `git push`, `rm` or `dropdb`, and any call Pushary flags as destructive, is still sent to your phone.
* Approvals go back to your phone as soon as you answer any approval in that session, send it a new prompt, or approve at your agent's own prompt a call Pushary handed there. That last one works for Claude Code and for Codex calls checked before they run, whose completion Pushary sees.
* An approval counts as unanswered only once its wait has ended with nobody answering, so several approvals open at the same time never pause the next one. Approvals you may have answered at your terminal without Pushary seeing it, in Gemini CLI, OpenCode, Cursor's shell and MCP approvals and Codex's own approval prompt, never count, so those sessions are never paused.
* Earlier CLI versions are paused only for Claude Code, and only where the call would have ended in Claude Code's prompt anyway. In a session started from your phone, CLI 1.9.6 to 1.9.12 refuse a paused call with their message that the remote session has no local approval UI. The Pushary Mac app keeps sending every approval to your phone for now.

## 1.9.18 [#1918]

*Notes corrected on October 4, 2026. The first version described only the Cursor case and left out the setup and skill text changes.*

* `pushary disconnect` leaves a config file it cannot read exactly as it is and lists it as untouched, for every agent. For Cursor it also keeps the plugin folder when the hooks file that points into it cannot be read, so Cursor's gate never points at a script that was deleted.
* After setup, the line on how to test reads "Run a command that needs approval. Away from this computer, it reaches your phone." The bundled Pushary skill now says When I'm out waits 10 seconds for your phone by default, not 45.

## 1.9.17 [#1917]

*Notes corrected on October 4, 2026. The first version said a rule that approves on timeout lets the call run under When I'm out. It does not: the call is refused.*

* When Codex runs with its approval policy set to never (full access), every call Pushary asks about goes to your phone, also while you are at the keyboard. Codex has no prompt of its own to ask you there. The wait is your policy's timeout, also under When I'm out.
* If nobody answers, the call is refused with "No response within timeout". Before, the command ran once the wait ended, a destructive one too, and at the keyboard it ran without anyone being asked. A wait cut short by Codex's hook time limit, and a question no phone could receive, are refused the same way.
* In Every time, a rule's timeout action still applies after its full wait: approve on timeout lets the call run, and deny on timeout refuses it. Under When I'm out, an unanswered call is refused whatever the rule's timeout action says.
* In Codex's other approval modes nothing changes. The call goes back to Codex, which asks in its own prompt when the call needs it.

## 1.9.16 [#1916]

* `pushary setup` names the account before it reuses a key: the key saved on this machine, `PUSHARY_API_KEY`, or a key found in your agent settings. At a terminal it asks `Continue as @workspace? (Y/n)`, and No connects a new key the way you asked: the Pushary app on your phone by default, or a browser sign-in with `--connect browser`. Without a terminal it names the account and prints `Wrong account? Run npx pushary@latest setup --connect app`. A key found in your agent settings is called the Pushary for Mac key only when Pushary for Mac is installed. A key on an inactive plan names its account and the same `--connect app` line instead of telling you to re-run setup with the saved key.
* The pairing screen prints the QR code last, directly above the waiting line, so it no longer scrolls off a 24-row terminal. Above it: what to scan, the short link, the fingerprint in plain words, the app link, and where to get the app. The browser fallback is offered once, after a minute.
* Stopping setup with SIGTERM while it waits for the phone cancels the pairing, as Ctrl-C already did. An agent whose tool call times out no longer leaves a live QR behind.
* Setup saves a paired key as soon as the key is checked, before it asks which agents to set up. Stopping at the agent list keeps the key, and the next run does not draw a new QR.
* When the phone answers the test question, setup ends with `You're set. Your phone answered in 3s.` and one line asking you to restart open agent sessions. The two "Agent hook activation remains unverified" lines are gone. A test nobody answered now shows `! No answer yet` instead of a tick.
* Setup says `Signed in to @workspace (Agent plan)` instead of `Key verified (workspace · plan agent)`, and names the agents Pushary for Mac handles in plain words.
* The transcript notice is one line: transcripts sync redacted and encrypted, your phone can decrypt them, authorized Pushary compliance admins can recover them for documented legal obligations, and the command that turns sync off. Transcript sync is still on by default.
* The two questions after setup wires your agents say plainly what they change: a Pushary section in this folder's `CLAUDE.md` or `AGENTS.md`, and a `claude` alias in your shell profile. Both still default to No.
* On Windows every printed `npx pushary@latest` command reads `npx.cmd pushary@latest`, which PowerShell runs without the execution policy blocking it.
* When npm cannot install globally (EACCES or EPERM), setup says to use nvm or set an npm prefix, instead of offering a retry that fails the same way.
* Setup prints one line before it installs the phone-start background service, with `--control off` to turn it off.
* When Pushary for Mac is signed into a different account, setup names both accounts and the two ways out: sign Pushary for Mac into this setup's account, or take over the hooks with `--take-over-hooks`.
* An unreachable phone is pointed at `npx pushary@latest setup --connect app` to pair the Pushary app, not at web push.
* On an unsupported Node, `pushary` says which releases it needs, which one you have, and where to get Node.js.

## 1.9.15 [#1915]

*Notes corrected on October 4, 2026. "Allow for this session" for an MCP tool also reaches Claude Code questions; the first version said Codex only.*

* Codex in Every time asks your phone only about the calls that matter. Codex raises its own approval when a command leaves its sandbox, a forced `rm` runs, an MCP tool is not marked read-only, or a patch lands outside the project, and Pushary answers that request in your mode as before. Before a call runs, Pushary now adds a question only when the call leaves the scope you agreed, a rule you wrote, a preset you picked or an approval route covers it, the command destroys, rewrites history or reaches the network, or a patch deletes a file. Commands that only build, test or read no longer reach your phone, and an MCP tool Codex asks about itself is asked once, through Codex's own request. The kill switch and your deny rules still apply to every call.
* In Every time with full access, where Codex asks nothing itself, every call your policy gates still comes to your phone, as before.
* When I'm out is unchanged for Codex, except for scope: Codex's own approval requests go to your phone first, and nothing else is asked before a call runs.
* A Codex edit outside the scope you agreed is now asked in Every time and When I'm out, also while you are at the keyboard, because Codex has no prompt for it there. Yes lets it run. No refuses it. No answer before your policy's wait ends refuses it with the path named. In Updates and Terminal, where nobody would be asked, it is refused. A patch that leaves the scope across several files is refused with a request to split it into single-file edits, as with Claude Code. Before this release Codex applied these edits without asking.
* In Updates, Pushary sends an update before a Codex call only for the calls above. Codex's own approval requests still send one each.
* A patch whose `*** Delete File:` or `*** Update File:` header is indented, which Codex applies, is now read as the delete or edit it is, so your path rules and the delete question apply to it.
* A command that deletes through a cloud CLI subcommand spelled as one word, such as `aws dynamodb delete-table`, `aws ec2 terminate-instances`, `heroku apps:destroy` or `firebase firestore:delete`, now counts as destructive for every agent. Pushary asks about it instead of leaving it to the agent's own allowlist, and an "allow Bash for this session" grant does not cover it.
* Codex questions can offer "Allow for this session" for Bash, where risky commands still ask, as Claude Code questions already did.
* After three approvals in a row for one exact MCP tool, the question can offer "Allow for this session" for that tool, in Claude Code and in Codex. It is never offered for Pushary's own tools or for a tool whose name says it runs code, sends, merges, publishes, deploys, writes, deletes or moves money.

## 1.9.14 [#1914]

* Antigravity CLI approvals go to your phone every time. agy has no approval prompt of its own while Pushary is its only gate, so under When I'm out the phone is no longer skipped because you are at the keyboard, and the wait is your policy's timeout instead of the short push window. Before, such a call was blocked with nobody asked, or after 10 seconds when you were away. Other agents keep When I'm out as it was.

## 1.9.13 [#1913]

*Notes corrected on October 4, 2026. The last two bullets, the setup receipt and the Windows exception were missing when 1.9.13 shipped.*

* `pushary setup` makes Pushary the only gate for Antigravity CLI. When `~/.gemini/antigravity-cli/settings.json` has no `toolPermission`, setup sets it to `always-proceed`, so plain `agy` no longer asks in its own prompt and approvals from your phone take effect. A mode you chose yourself, such as `strict`, is left alone, and setup says agy will still ask in its own prompt. Setup records the change in `~/.pushary/setup/antigravity-tool-permission.json`.
* `pushary disconnect antigravity` and `pushary clean` put `toolPermission` back, but only if Pushary set it and only once no Pushary hook is left in `~/.gemini/config/hooks.json`. A value you set or changed is never touched.
* An Antigravity CLI call that Pushary cannot decide is now blocked with a reason instead of running unasked: when Pushary is signed out, cannot be reached, or cannot establish its policy. Other agents are unchanged and still fall back to their own prompts.
* If the Pushary CLI is uninstalled while agy is still connected, agy's approval hook blocks each call and says how to undo the setup, instead of exiting silently and letting the call run. On Windows the hook still exits silently in that case, and agy runs the call.
* A session started from your phone asks your phone every time under When I'm out, also when this computer looks attended, and waits for your policy's timeout. Before, when another session had prompted in the last five minutes or Pushary for Mac was attended, the phone was skipped and the call was denied with "no local approval UI". Nobody was asked.
* The Cursor plugin setup installs asks your phone about every file change under When I'm out, also while you are at the keyboard, and waits for your policy's timeout. Before, the edit was denied with "Switch to Every time" and nobody was asked, or it was denied after the 10 second push window when you were away. Shell commands and MCP calls in Cursor keep When I'm out as it was, because Cursor can prompt for those itself.

## 1.9.12 [#1912]

*Notes corrected on October 4, 2026. 1.9.12 shipped with no notes. The bullets below were added in the 1.9.13 and 1.9.15 packages, and the error text and the refused options in full were added on October 4.*

* An Antigravity CLI tool call that failed is recorded as failed in the session, where it used to show as completed. The session now shows the call's error message: up to its first 500 characters, with secrets redacted, as for other agents.
* `pushary disconnect fx` is recorded in `~/.pushary/declined-agents.json`, so Pushary for Mac versions that read that file leave fx off until you connect it again.
* `rg`, `sort`, `uniq`, `sleep`, `pgrep` and `git branch --show-current` run without asking when they only read. This applies to every agent. `rg` still asks with an option that runs another program (`--pre`, `--pre-glob`, `--hostname-bin`, `--search-zip`, `-z`). `sort` still asks with an option that writes a file or runs a program (`-o`, `--output`, `-T`, `--temporary-directory`, `--compress-program`). `uniq` still asks with a second file, which it writes.
* Codex's `wait_threads` and `send_message_to_thread` run without asking, matched by exact name. The kill switch, a deny rule and a rule you wrote for the tool still win over them.
* A deny rule now blocks read-only commands too. A bare `Bash` deny, a `*` deny or a preset that never runs the shell used to let `ls` and other reads through.

## 1.9.11 [#1911]

* `pushary setup` connects Antigravity CLI (`agy`). Pick it in setup or pass `--agents antigravity_cli`. Setup adds a hook named `pushary` to `~/.gemini/config/hooks.json` for `PreToolUse`, `PostToolUse` and `Stop`, and the Pushary MCP server to `~/.gemini/config/mcp_config.json`. Before agy runs a shell command, writes or edits a file, or calls an MCP tool, your policy decides, and the risky ones wait for your answer on your phone or your Mac. Pushary answers agy only with allow or deny: a denial, or no answer before your policy's wait ends, blocks the call with a reason the model sees.
* Approvals for Antigravity CLI take effect only when agy runs with `--dangerously-skip-permissions` or with `"toolPermission": "always-proceed"` in `~/.gemini/antigravity-cli/settings.json`, because agy ignores a hook's allow in its other modes. Setup prints this and does not change agy's mode. Pushary is then the only gate: if the hook cannot reach Pushary, agy runs the call.
* Setup skips Antigravity CLI when `agy` is not installed, even when `~/.gemini` exists for Gemini CLI.
* While agy waits for your answer, its terminal shows "If nobody answers, it does not run." instead of saying the terminal takes over, which agy has no way to do.
* `pushary disconnect antigravity` removes the `pushary` hook and the Pushary MCP server and leaves your other hooks and servers alone.

## 1.9.10 [#1910]

* `pushary setup` no longer reports Qwen Code, CodeBuddy, Qoder, Droid and Devin as an account mismatch when Pushary for Mac connected them and the CLI's key is in the same account. Setup compares the account of the key in their MCP entry for Qwen Code, CodeBuddy and Qoder, and the account of the Mac app's own key for Droid and Devin, whose hooks run through the app. They are kept and listed as kept for the Mac app. If the app is in a different account, setup reports it and changes nothing. The CLI does not copy or save the app's key.
* `pushary doctor` no longer fails "Global package installed" on a computer Pushary for Mac connects, for example when run with npx. The app runs the hooks there, so doctor prints that the global package is not installed and not needed. It still fails when the CLI has its own key or owns any agent's hooks, because those hooks run the global package.
* `pushary clean --everything` revokes the keys the CLI wrote on pushary.com before removing them: the key in `~/.pushary/config.json`, and a different key in the `export PUSHARY_API_KEY=...` line setup writes to your shell profile. It says whether each key was revoked. A key that is only in the `PUSHARY_API_KEY` environment variable is left alone and named, because Pushary did not write it and it may be a server key you use elsewhere. If pushary.com cannot be reached, the clean still finishes and tells you where to revoke the key. `--dry-run` revokes nothing and lists the keys it would revoke. The Mac app's key is never revoked, and a plain `clean`, `disconnect` and `sign-out` without `--revoke` behave as before.
* `pushary setup --take-over-hooks` takes over Droid's hooks from Pushary for Mac. It used to fail with "no Mac app wiring was found", because Droid keeps its hooks at the top of `~/.factory/hooks.json`.

## 1.9.9 [#199]

* The VS Code hooks setup writes now run the gate through the same shell guard as every other agent. Before, a missing Node or a deleted plugin folder made the VS Code hooks fail on every tool call; now they stay silent and VS Code carries on as if Pushary were not installed. Run setup again for VS Code to get the guarded hooks.
* `pushary doctor`, `pushary status` and `pushary pair` recognise a computer Pushary for Mac connects when the CLI has no key of its own. Doctor and status say the computer is connected through Pushary for Mac instead of reporting a missing key, and pair tells you to pair a phone from the app's Settings > Phone. The CLI does not use, copy or save the app's key.
* A default `pushary setup` turns on phone-start when `~/.pushary/config.json` exists but has no `controlMode`, as `pushary login` and the Mac app's Hermes connection leave it. Before, setup skipped phone-start on those machines. `--control off`, or a saved `controlMode` of `off`, still keeps it off, and upgrades still never add the background service on their own.
* `pushary setup` keeps an OpenCode plugin Pushary for Mac installed, as it already did for the other agents, and lists it as kept. It used to overwrite the app's plugin, MCP key and instructions. Pass `--take-over-hooks` if you want the CLI to own it. If the app is signed into a different account, setup reports that for OpenCode and changes nothing.

## 1.9.8 [#198]

*Notes corrected on October 4, 2026. The first three bullets were missing when 1.9.8 shipped.*

* Phone pairing is now `pushary pair` and signing out is `pushary sign-out`. `pushary connect` and `pushary logout` still work as aliases, with the same flags. Setup, status, doctor and `pushary bell` say "pair a phone".
* `pushary disconnect fx` removes what setup added for fx: the Pushary server in `~/.fx/mcp.json`, the permission rules setup recorded, that record, and the Pushary block in `AGENTS.md`. Your own entries are left alone. With nothing connected it says fx was not connected and changes nothing.
* `pushary mode` accepts `updates-only` and `updates_only` for Updates (`notify_only`). Setup and disconnect accept both agent id forms, such as `claude_code` or `claude`, and reject an unknown id with the list of valid ones.
* `pushary upgrade` and automatic updates no longer take over agents Pushary for Mac connected. They used to replace the app's hooks with the CLI's and overwrite its MCP key for Claude Code, Codex, Gemini CLI, VS Code and OpenCode. An agent the app owns is now left exactly as the app wrote it and listed as kept for the Mac app, using the same rule setup uses. Pass `--take-over-hooks` to setup if you want the CLI to own it.
* `pushary clean` keeps the Mac app's wiring for Qwen Code, CodeBuddy, Qoder, Droid and Devin while the app is installed, as it already did for the other agents. `clean --everything` still removes it.
* `pushary disconnect cursor` removes the Cursor plugin setup installed in `~/.cursor/plugins/local/pushary`, including the `mcp.json` that held your API key, and setup's leftover copies of it. The plugin is kept, and the output says so, when the gate in `~/.cursor/hooks.json` that points into it could not be removed.
* `pushary disconnect` removes the Pushary block it wrote to `AGENTS.md` (Codex, OpenCode), `GEMINI.md`, `QWEN.md` and `CODEBUDDY.md`. Only the text between the Pushary markers is removed. Skills are left in place.
* `pushary disconnect <agent>` is no longer undone by the Mac app. It records the agent in `~/.pushary/declined-agents.json`, and Pushary for Mac versions that read that file leave the agent off until you connect it again from the app or with `pushary setup`.
* `pushary mode`, `mode clear`, `wait <seconds>` and `suggestions` no longer say "This key was rejected" when the key is fine. Keys from `pushary login`, phone pairing and the Mac app cannot change approval settings, and these commands now say so, point you to the Pushary app, your phone or the dashboard, and exit with code 2.
* `pushary sign-out --revoke` revokes those keys too, and then checks with pushary.com and tells you whether the key still works. Before, it could not revoke them and always said the key was still valid. `--json` adds `keyStillValid`.
* When the Mac app signs out of the key setup borrowed from it, the background service stops once instead of restarting every 10 seconds, and `pushary doctor`, `pushary status` and commands that report a rejected key say the key was signed out on this Mac, tell you to run `pushary login`, and name the shell profile line that still exports the old key. Pushary does not edit that line. A background service with no key at all also stops instead of restarting.

## 1.9.7 [#197]

* `pushary claude` and the `pushary daemon` commands wait at most 5 seconds for the background service again. Only setup and upgrade allow the 30 seconds a cold Windows start can need, so launching Claude no longer sits silent while the service starts.
* An automatic update whose configuration refresh fails now retries after 5 minutes, then after an hour, then once a day, instead of every 5 minutes. On a Mac with phone-start on, each retry restarted the background service.
* A refresh that cannot succeed until you change something (a legacy phone-start service, phone-start turned on without a usable agent, or a config file Pushary cannot rewrite) is no longer retried automatically. `pushary doctor` shows it, and running `pushary upgrade` after the fix finishes it.
* When a Codex approval hook is turned off in Codex, setup and upgrade tell you to enable it in `/hooks` instead of asking you to trust it. A missing or background (asynchronous) approval hook points you to setup again, as doctor does.
* Upgrades, including automatic ones, regenerate the OpenCode plugin Pushary installed, so the 1.9.4 fix, which makes OpenCode approvals use the directory OpenCode is working in, reaches existing installs without running setup again. A `pushary.js` you wrote yourself is never touched, and no plugin is added where there was none.

## 1.9.6 [#196]

* Read-only shell approval no longer covers commands that make the shell evaluate quoted text again: arithmetic expansion (`$[ ]`), subscripted parameters (`$name[ ]`, including zsh flag prefixes) and `printf -v`. These ran a quoted command substitution in bash or zsh while being approved without asking. They now go to your normal approval.
* An escaped `;`, `&` or `|` no longer splits a command when rating its risk, so destructive words passed as arguments to `sh -c` keep the command destructive and above a standing Bash auto-approve.

## 1.9.5 [#195]

* Setup allows up to 30 seconds each for daemon startup and heartbeat/control proof, allowing cold Windows agent discovery to finish before reporting a failure. Healthy services return immediately.
* Failed phone-start checks show their available local error and report which stage failed, so installation, service startup and server readiness failures can be distinguished.

## 1.9.4 [#194]

* OpenCode approvals use the active directory for project names, policy and relative targets, including nested Git sessions and non-Git workspaces. Run setup again after updating to regenerate an existing plugin.

## 1.9.3 [#193]

* Shell approval checks preserve non-shell Unicode whitespace as part of the executable name, so an unfamiliar command cannot inherit a read-only command’s approval exemption. Shared command analysis keeps risk classification and human approval policy aligned.

## 1.9.2 [#192]

* Setup, doctor and login finish writing their output before exiting, including when output is piped. Windows setup saves the key without printing it when no shell profile is available.
* Editor approvals stop waiting when a question is missing or withdrawn. Pending configuration refreshes retry after five minutes, readiness tolerates client clock skew, and activation checks follow symlinks.
* Codex coverage requires enabled, trusted synchronous permission hooks. Native permission requests show their redacted input without treating it as a shell command or file edit.

## 1.9.1 [#191]

* **Fewer approvals for commands that only read.** A chain of reads joined by `;` or `||`, a `|`, `\` or `{` inside quotes (as in `grep "a\|b" src/` or `grep '^{' file`), `sed -n 50,66p file` and `date '+%H:%M:%S'` no longer wait for you. Before, any of these sent a prompt to your phone or the Mac notch.
* **A read is no longer treated as destructive because of a word it reads.** `tail -5 release.log`, `grep "DELETE FROM" src/db.ts` and `cat deploy.log` were rated destructive because of `release`, `delete` or `deploy`, and a destructive rating overrides your own "auto-approve Bash" rule. They are now rated by what they do. A command that can act is rated as before, including a read piped into a shell or a database client, such as `echo "rm -rf ~" | sh`.
* `git`, `find`, `sed` and `date` now ask when an argument is something the shell expands, such as `$VAR` or a glob at the start of a word. An expansion like that can turn into a flag the check never saw, for example a file named `-delete` matched by `find . -name *`.
* Setup's global install now takes the same lock as `pushary upgrade` and automatic updates, so it never installs over an upgrade that is already running. (#1837)

## 1.9.0 [#190]

* When you scan setup's QR code with the Pushary app, the app now shows which computer is asking to connect: its name, whether it is a Mac, Windows or Linux computer, and the agents setup found on it. Before, it showed only the fingerprint. This needs Pushary app 1.0.31 or later; older apps work as before.
* Denying the request in the Pushary app now stops setup at once with "You denied this computer on your phone". Before, setup kept waiting until the code expired.
* Setup's report to your workspace now says which kind of computer it ran on, so the Pushary app can show it next to the computer.

## 1.8.3 [#183]

* Checking installed agents no longer blocks the daemon while npm or PATH lookups run. Concurrent refreshes share one lookup, and stopping the daemon cancels discovery.
* Automatic and manual upgrades share an operating-system lock. The finishing process keeps it if its parent exits, and a crash releases it without leaving a recovery file that blocks later upgrades. Unavailable locks stop the upgrade.

## 1.8.2 [#182]

* **Starting Codex from your phone no longer picks an old, broken Codex over the one you use.** The daemon looked for agents in npm's global folder before the ones your shell runs, so a broken npm copy of Codex won over a working one elsewhere on your PATH, and the session died at once with `spawn ... ENOENT`. On macOS and Linux the daemon and both session bridges now start the agent your shell finds first. Windows keeps npm's `.cmd` launcher first, because the first match on PATH there can be a script Windows cannot run.
* A Codex install with no native program left in its package, as XProtect left some npm installs, is no longer offered to your phone, and a request for it fails with the path it found and "Reinstall Codex". This is read from the disk; Pushary never runs the agent to check it. Setup, `pushary doctor` and `pushary upgrade` still treat that Codex as installed, as before, so they never stop the background service because of it, and they check the service against the agents it can actually start, so a broken Codex does not make them report that the service failed.
* The daemon checks every minute which agents it can start, so installing or repairing an agent shows on your phone without restarting the daemon. The daemon log says when that list changes.
* The daemon log now records how each session started from your phone ended: finished, stopped from Pushary, interrupted, stopped by a signal, or exited with its code, and after how long. Only an exit with an error code is recorded as the daemon's last error, which `pushary daemon status` and `pushary doctor` show. Stopping a session from your phone, or the kill switch halting it, is not an error.
* The Codex install check that setup also uses no longer judges a standalone Codex by an unrelated npm copy in a folder above it.

## 1.8.1 [#181]

* The CLI is now also published as `pushary`, from the same build as `@pushary/agent-hooks`, and the commands it prints now show `npx pushary@latest`. `npx @pushary/agent-hooks@latest` keeps working.

## 1.8.0 [#180]

* **An approval you give after auto mode blocks a call is no longer lost when the agent rewords the call.** Your approval covers only the exact call that was blocked. Claude Code tells the agent only that it may retry, and an agent that sent a changed command was blocked again, so the approval you gave from your phone or the Mac notch did nothing. Pushary now refuses the first changed call and tells the agent to send the blocked call again unchanged. If the agent ends its turn without sending it, Pushary tells it to send it.
* Claude Code no longer tells your phone and the Mac notch that it is waiting for you while its background tasks are still running. Claude Code reports itself idle after a minute at the prompt even when it will continue by itself once those tasks finish. A question from the agent still reaches you as before.
* A prompt longer than 500 characters, or a shell command longer than about 490, no longer stops your agent at its next phone approval. The hook sent the whole text and the server refused it, so Claude Code halted with "Pushary could not create a verifiable approval" and Codex and OpenCode denied the call. The question, intent, action, blocker and agent name are now cut to what the card can show, and a cut line ends in "…". The server now does the same for every older CLI, so this fix does not wait for you to update. (#1604)
* A line cut to fit, including a long diff, never ends on half an emoji. The server stores these lines as JSON, and Postgres refuses a half character, so the approval failed to save.
* `pushary doctor`, `pushary upgrade`, `pushary clean` and automatic updates recognise a global install under either package name, `@pushary/agent-hooks` or `pushary`. A machine keeps the name it already has, and setup on a new machine installs the name it was run from. Nothing changes for an existing install.
* `pushary doctor` flags a machine with both names installed globally, because uninstalling either one removes every Pushary command.
* `pushary upgrade` no longer installs over an automatic update that is still running. It says another upgrade is running, with its process id, and stops.

## 1.7.3 [#173]

* **Approval text never hides part of a command.** The value after a credential name is now hidden only up to the first space, quote or piece of shell syntax. 1.7.2 could still hide a command: `eval TOKEN="x; rm -rf ~"` read `eval TOKEN="[redacted]"`, `password= reboot` read `password= [redacted]`, and `rm -rf {password=x,/}` hid the `,/` that also deletes `/`. A private key block is hidden only when it holds nothing but the key. Tokens, keys and quoted values without spaces are hidden as before. A quoted value with spaces now shows what follows its first word, as in `--password='[redacted] pass'`. Logs and error reports still hide the whole value.

## 1.7.2 [#172]

* **Approval text shows the whole command again.** A credential name that closes a quoted string, as in `grep -rl "password=" . | xargs rm -f`, made 1.7.1 redact everything after it, so the approval read `grep -rl "password="[redacted]"` and hid the `rm`. The value after a credential name is still redacted, and the rest of the command is shown.
* **Hermes works again after an uninstall.** When setup found Pushary's own Hermes settings already in `~/.hermes/config.yaml`, left by an earlier install, its record of your config included them, and `pushary clean` put them back: approvals stayed pointed at the plugin clean had just uninstalled, and Hermes' `clarify` tool stayed off, so Hermes could not ask you anything in the terminal. Clean now recognises Pushary's own values in that record, including records older versions wrote, and removes `transport: pushary`, the `pushary` plugin entry, and the `clarify` entry that came with Pushary's transport, while restoring everything else you set. Running clean again, or after the Mac app has disconnected Hermes, no longer fails once Hermes' defaults fill the removed settings back in.
* `pushary clean` says what it did to Hermes: "Pushary settings removed" only when it changed `config.yaml`, "no Pushary settings" when there was nothing of ours, and it skips the plugin uninstall when the plugin is not installed. `--dry-run` previews the exact change without saving it.
* `pushary doctor` checks Hermes when Pushary set it up: that the plugin is installed in Hermes' Python and enabled, and whether approvals and questions go through Pushary. A plugin the Mac app left installed but disabled is not reported as a failure.
* Setup on a machine without npm now says so and asks you to install Node.js, instead of printing `/bin/sh: npm: command not found` and suggesting an `npx` retry that needs npm too. Pushary still needs npm; bun, pnpm and yarn installs are not supported yet.
* `pushary clean` tells an npm it cannot find, a package that is not installed and a failed uninstall apart, instead of calling each of them "not installed". A failed uninstall no longer ends in "Clean complete".
* `pushary clean --dry-run` lists only the Mac keychain items and preference domains that exist, and the fx setup record only when there is one. It used to list every candidate it would try. A keychain that cannot be read, for example while locked, still counts as possibly holding Pushary's items, so clean tries them and reports a failure instead of calling the keychain clean.
* `pushary clean` honours `NO_COLOR`.
* Setup's agent picker shows only the names you picked once you confirm, instead of repeating every agent's description, and the transcript notice is indented like the lines around it.
* A message you send from your phone or the Mac notch while Claude Code is running a subagent now waits for Claude Code itself. It used to be handed to the subagent's next tool call, where the main conversation never saw it.
* When your Pushary workspace has no active subscription, Pushary now steps aside and your agent's own approval prompt decides, as it does when Pushary is not installed. Claude Code, Codex, Gemini CLI and OpenCode used to refuse gated tool calls instead, telling you to retry or that the approval was cancelled, and Claude Code questions, plan approvals and MCP forms stopped the same way. A kill switch and your deny rules still apply.
* Your agent's terminal says once per session why Pushary stepped aside, with the link to subscribe.
* A Claude Code or Gemini CLI session started from your phone has no prompt on your machine, so it still refuses the call, now saying the workspace has no active subscription instead of asking you to retry.
* Pairing your phone during setup now says when your workspace has no active subscription, and to subscribe in the Pushary app or at pushary.com before running setup again. It used to say only that pairing failed.

## 1.7.1 [#171]

* **fx asks through Pushary.** Setup now adds `"ask_user_question": "deny"` as the last rule in `~/.fx/settings.json`, which removes fx's own terminal question tool from what its agent can call, so every question goes through `mcp_pushary_ask_user`: to the Mac notch at the Mac, to the phone away from it. fx cannot forward its own prompt, so a question asked there used to wait unseen once you walked away. A rule you already set for `ask_user_question` is kept, and setup names it. The instructions in `~/.fx/AGENTS.md` now tell fx's agent to load `mcp_pushary_ask_user` with `mcp_select_tool` by exact name and to ask there even while you are at the terminal, and to ask in its reply only when Pushary hands the question back or cannot be reached.
* fx's full-access mode (`yolo`, `full-access` or `full access`, from settings, a workspace, or `FX_PERMISSION_MODE`) ignores permission rules, so the terminal question tool stays on there; setup and `pushary doctor` say so instead of claiming questions are routed, and the instructions still steer the agent to Pushary. fx workspaces with their own permission rules replace the global ones, and setup and doctor name how many keep the question tool on. Setup reads the rules the way fx does (globs, last match wins, per-target maps) and leaves a `settings.json` fx would reject, such as one with an unknown action or permission mode, untouched and says fx ignores it.
* `pushary clean` removes the question rule only when setup recorded adding it and it is still `deny`, so a rule of your own survives.
* `pushary clean` now removes Pushary entries from every event in `~/.cursor/hooks.json`, not only the events the permission gate uses. The Mac app registers its bridge on session, compaction and stop events too, and those eight entries were left behind under "Clean complete". Other tools' hooks are untouched.
* `pushary clean` now removes the Pushary block from OpenCode's `~/.config/opencode/AGENTS.md`, as it already did for Codex and Gemini. Setup wrote it and clean left it.
* `pushary clean` removes temp files that an interrupted config write left next to an agent's config (`.<file>.pushary-<id>` and `.<pid>-<time>.pushary-tmp`), only next to the agent configs clean rewrites (your home folder, Claude Code, Codex, Gemini, Cursor, OpenCode, fx and VS Code settings), never through a symlink, and only once they are over a minute old.
* Setup's summary no longer says "(others completed successfully)" or "Other agents will continue" when the failed agent was the only one; it names the agents that were configured.
* Setup's progress lines no longer leave the tail of the previous frame behind ("with Codexex", "tap the notificationon"): setup uses the shared spinner, which clears the line, keeps each frame to one terminal row, and does not animate into a log when colour is forced on.

## 1.7.0 [#170]

* **fx.** `npx @pushary/agent-hooks@latest setup --agents fx`, or ticking fx in the picker, connects Vercel Labs' fx coding agent. Setup adds a `pushary` server to `~/.fx/mcp.json` that runs the new `pushary-mcp` command, a local bridge that signs in with the key setup saved in `~/.pushary`. No key is written to fx's files, and a rotated key is used without running setup again. fx has no hooks other tools can register, so Pushary cannot answer fx's own approval prompts; fx's agent asks through Pushary's tools when it chooses to, guided by a managed block setup writes to `~/.fx/AGENTS.md`.
* Setup adds `"mcp_pushary_*": "allow"` to the `permission` rules in `~/.fx/settings.json`, after your own rules, so fx runs Pushary's tools without reviewing or prompting for each call, the same as the other agents' auto-allowed Pushary tools. A rule you already set for `mcp_pushary_*` is kept. fx workspaces that set their own permission rules replace the global ones, and setup names how many there are.
* Setup leaves `~/.fx/mcp.json` and `~/.fx/settings.json` untouched when fx itself would reject or refuse to edit them (comments, a trailing comma, a repeated key, or servers under a key fx ignores) and prints the command that retries only fx. It writes both files as compact JSON, the way fx does, and leaves a file alone rather than grow it past the size fx reads. It skips fx on a machine with no `~/.fx`, and on Windows, which fx does not support. fx is ticked automatically only when fx's own files are there, since other tools use `~/.fx` too.
* `pushary doctor` checks the fx entry and that its bridge is installed, and warns when Pushary's tools are not auto-allowed. `pushary clean` removes only the Pushary server, the allow rule it added, and the instructions block.
* `pushary setup --help` lists every agent id setup accepts.

## 1.6.4 [#164]

* Requests to Pushary now say which client made them: the CLI version, the platform, a per-process run id, and the machine id this machine already has. They go only to Pushary's own address, never to npm or any other host, and never include file paths, keys or content. Support can then find a problem from your account instead of asking for terminal output.
* When setup, a hook or the bridge cannot reach Pushary, cannot claim a blocked action, or stands aside for an agent it does not recognise, it now tells Pushary with a short code such as `mode_fetch_failed`. Each code is sent at most once per clock minute per machine, not per hook, even when several hooks fail at the same moment, so an outage does not add a request to every tool call. `~/.pushary/client-reports/` holds one small claim file per code per minute. A report gives up after one second. Set `PUSHARY_DISABLE_CLIENT_REPORTS=1` to send none.

## 1.6.3 [#163]

* When setup cannot configure one of the agents you picked, the final summary now names that agent, says why, and prints the one command that retries only it, such as `npx @pushary/agent-hooks@latest setup --agents cursor`. Before, the reason was printed once in the middle of the run and the summary only said "Setup finished with 1 problem".
* A config file setup refuses to rewrite, such as a `~/.cursor/hooks.json` or `~/.claude/settings.json` with comments or a trailing comma, is still left untouched and backed up next to the original. Fix or remove it, then run the retry command; it reuses your saved key and does not pair your phone again.
* `setup --json` adds `agentFailures`: one entry per agent that failed, with its reason.
* Setup's report to your own Pushary workspace now says which agent failed and why (the agent and a reason code only, never a file path or file contents), which check decided the exit code, and the CLI version. Support can then see what went wrong without asking you to paste terminal output.

## 1.6.2 [#162]

* "Allow Bash for this session" now still asks before rsync deletes files: `--del`, `--delete-delay`, `--delete-missing-args`, `--remove-sent-files`, and a long option shortened to a unique prefix such as `--delete-dela`. It also still asks for `git checkout -f`, `git checkout <ref> -- <path>`, `git switch` with `-f`, `--force` or `--discard-changes`, branch resets (`git checkout -B`, `git switch -C`, `git branch -f`, `-D`, `-M`, `-C`), and `redis-cli flushall` or `flushdb` in any letter case, wherever the flag or word appears. Before, the grant ran these without asking. `git checkout HEAD file.ts`, which overwrites a file without a `--`, still runs under the grant.
* The same commands now ask even when your own Claude Code allow rules cover them, such as `Bash(git:*)` allowing `git checkout origin/main -- package-lock.json`. Pushary still leaves every other command those rules allow to Claude Code.

## 1.6.1 [#161]

* Pushary-launched Codex sessions can answer supported questions from inside MCP tools through Pushary. Invalid answers and cancelled requests never become approval. This does not connect existing Codex Desktop Computer Use permission dialogs.
* Claude forms with rules Pushary cannot preserve now stay in the native client instead of silently losing those rules.

## 1.6.0 [#160]

* Pushary no longer asks about a Claude Code command your own Claude Code allow rules already cover when only a Pushary default would have asked. Risky commands still ask: destructive, network and data-loss commands, and anything whose effect cannot be read from its text, such as `bash -c`, inline interpreter code, `xargs` or a `#` comment. If Claude Code prompts anyway, the approval still reaches your phone.
* Your Claude Code rules are read from your managed, user and local settings. A repository's committed `.claude/settings.json` can only add asks and denies, so a cloned repository cannot switch Pushary off.
* After three approvals of Bash in a row in one session, the phone and the Mac offer "Allow Bash for this session". Risky commands still ask, and a command the grant holds back is delivered exactly as it was before the grant.
* "Approve for this session" no longer saves a rule for a risky command, or for a wrapper such as `bash -c` or `git -C` that would cover every command after it.
* A preset you picked in Policies now applies on sites that have an Approvals mode set, which is nearly all of them. The Approvals mode still decides where an approval goes.
* A call your team routes to an approver keeps that approver, whatever your own Claude Code settings allow.
* An automatic update whose agent configuration refresh fails now stays pending and retries, instead of reporting success.
* A newer release now replaces a pending upgrade whose refresh keeps failing, so updates never stop. `pushary upgrade` prints what failed instead of a stack trace.
* Setup, upgrade and doctor no longer run a Codex binary that sits inside an app bundle when `codex` on your PATH points there directly or through a symlink.

## 1.5.1 [#151]

* Setup no longer stops at a Codex version. It writes the Pushary hooks, asks Codex to trust them, and checks Codex's answer. It used to trust the hooks itself only up to Codex 0.155.1, and on anything newer told you to open Codex and trust them by hand.
* Pushary asks Codex only when you run setup, upgrade or doctor yourself at a terminal, only through the `codex` command on your PATH, and only if Codex has been opened on this machine before. It never starts the Codex inside the ChatGPT app, and never while a hook is running.
* If Codex does not accept the trust, setup says so and tells you to open Codex, run `/hooks`, and choose Trust for the Pushary hooks. When Codex is not asked, setup says why in one line and keeps the trust entries it wrote itself, as it did before.
* `pushary upgrade` asks Codex the same way after it refreshes the Codex hooks. The daily automatic update refreshes the hooks and writes the same trust entries but does not start Codex, so an install left untrusted by the old version limit is fixed on its next update either way. Machines older than 1.5.0 do not update themselves: run `npx @pushary/agent-hooks@latest upgrade` once.
* `pushary doctor` shows what Codex itself reports for each Pushary hook: trusted, untrusted, modified, not listed, or turned off. When Codex is not asked or cannot be asked, doctor says so and uses its own check instead.
* Pause automatic updates on Linux to preserve phone-started sessions during daemon replacement.
* Retry incomplete configuration and daemon refreshes after an automatic installation, including when the installed version is already current.

## 1.5.0 [#150]

* Pushary now updates itself in the background. When an agent session starts, it checks at most once a day for a newer version within the same major version, installs it into the global npm folder your hooks already run from, and refreshes each agent's config the way `pushary upgrade` does. The session never waits for it. A new major version is shown in `pushary doctor` and left for you to install.
* Turn it off with `pushary upgrade --auto=off` (and back on with `--auto=on`), or set `PUSHARY_DISABLE_AUTOUPDATE=1` in the environment your agents start from.
* It does not run on Windows yet, in CI, or for a copy run through `npx`, a plugin, or the Mac app. It never uses `sudo`: if npm cannot write to the global folder, the attempt is recorded as failed and nothing changes.
* This only reaches machines on 1.5.0 or later. To get there, run `npx @pushary/agent-hooks@latest upgrade` once.
* `pushary doctor` shows whether automatic updates are on and the result of the last check, and `setup` and `doctor` tell you once when Pushary has updated itself.
* `pushary doctor` no longer calls a build newer than the npm release out of date.
* The commands the CLI prints for you to copy now say `npx @pushary/agent-hooks@latest`. Without `@latest`, npx runs whatever older version is installed globally.
* A failed npm install now reports npm's reason, such as a permission error, instead of a line like `syscall mkdir`.

## 1.4.2 [#142]

* Setup trusts the Pushary hooks for you on Codex up to 0.155.1. It used to stop at 0.147.0, so on a newer Codex it wrote the hooks without trusting them, Codex never ran them, and setup still said it was done.
* On a Codex newer than the last version Pushary checked, setup says so in one line and tells you to open Codex and choose Trust for the Pushary hooks.
* The phone QR stops waiting 10 seconds before the pairing code expires, so the code is cancelled cleanly on a timeout.
* After a minute at the QR with no scan, setup offers the browser sign-in: Ctrl-C, then `npx @pushary/agent-hooks setup --connect browser`.
* A kill switch or standing deny on Codex now appears in your decision history, as it already did for Claude Code. If that record fails to send, it is sent again on the next matching denial.
* `clean --everything` also removes the sign-in session the Mac app now keeps in the keychain.

## 1.4.1 [#141]

* `clean` masks credentials in shell lines it cannot rewrite, including output you might send to support.
* `clean --everything` stops before changing configuration if the Mac app refuses to quit. Keychain access failures are reported as incomplete cleanup; missing items alone count as absent, and permission prompts can finish.
* Cleanup passes discovered preference domains, app paths and keychain services as literal command arguments. A foreign skill named `pushary` is preserved unless the skills.sh lock identifies it as ours.

## 1.4.0 [#140]

* `pushary clean --everything` removes what the Mac app set up as well as what the CLI did. It quits the app, then removes its keychain items, preferences and caches, the editor extension it installs in Cursor and VS Code, and the skill's registration in `~/.agents`. A plain `clean` still leaves an installed Mac app alone, and now says so instead of printing "Clean complete." over a key it kept.
* `clean` tells you to run `unset PUSHARY_API_KEY` when your terminal still exports the key. Without it, `setup` in the same terminal signed you straight back in as the account you had just removed.
* `clean` no longer leaves your key behind in its own backup of your shell profile, in earlier copies of the Cursor plugin, or in the line `pushary logout` comments out.
* A line in your shell profile that still sets a real key, in a form `clean` will not rewrite, is reported as left behind rather than skipped.
* `clean`, `doctor` and `setup` name [business@pushary.com](mailto:business@pushary.com) and the Discord when they leave something broken.
* A plain `clean` after you delete the Mac app removes what the app left behind. It used to take the app's leftover locator file as proof the app was still installed, and kept every hook pointing at it. In Cursor those hooks deny whatever reaches them once there is no app to answer.
* `clean` removes the Pushary entry and its key from Claude Code's own backups of `~/.claude.json`, not only from the live file. Restoring one of those backups used to put a working key straight back. A backup from before setup keeps whatever you had there.
* A file edit no rule was written for goes straight to the agent's own prompt instead of waiting for your phone first, in Claude Code's default mode and when Codex is about to ask. Over 35 days these were asked 224 times and answered from a phone twice. A rule you wrote, a preset or mode you picked, and a scope contract still reach your phone, and runs that bypass permissions are unchanged, because there is no prompt to fall back to.
* A kill switch or a standing deny enforced on this machine now appears in your decision history, as it already did through the Mac app. Only what the machine allowed was recorded before.
* Qwen Code, CodeBuddy and Qoder keep the answer you give on a permission prompt. Devin's patch and MCP calls reach the gate that was installed for them. A hook naming an agent Pushary does not recognise with `--source` stands aside, as it already did with `--agent`, rather than acting as Claude Code.
* `doctor` reads hook commands written in quotes or with `--source`, and tells a malformed MCP registration apart from a configured server.
* A hook payload that is not the shape it claims to be is refused before it can change anything.

## 1.3.1 [#131]

* Keep human-review policies effective inside shell chains, and refuse automatic approval of quoted command substitutions.
* Check kill switches and standing denials before rejecting unreadable tool targets. Check every file in a patch; ask the agent to split a batch that crosses scope.
* Preserve symlinked agent configuration files during atomic updates.
* The installed skill recognizes file-edit capabilities across agents, including Codex patches.
* `pushary doctor` warns when hooks are registered for an agent this version has no profile for. Every one of them stands aside, so nothing on that agent is gated or recorded until you upgrade.
* A hook that stands aside because it cannot resolve `--agent` says so in the documented `[degraded]` shape, so a stand-aside is countable instead of invisible.

## 1.2.0 [#120]

Nothing to run. These are the gate's own rules, tightened where they were guessing.

* A shell command Pushary cannot read is no longer judged on the loosest rule that fits. A tool whose command arrives under a key we do not recognise used to fall through to a bare `Bash` rule, which is always the permissive one; a path in the same position already refused to be judged. Both now say they have no opinion and let the agent ask you. An agent that names its command differently can declare the key instead of losing the gate.
* An `--agent` Pushary does not recognise stops the hook rather than turning it into Claude Code. A typo in a registered command used to fetch Claude's policy and file the session under Claude's name. Every hook now stands aside and says why, because acting as the wrong agent is worse than not acting.
* `pushary doctor` calls your hooks intact only when all of them are. It used to accept any single surviving hook as proof, so a config wiped down to one entry read as healthy.
* Setup no longer counts its own folder as proof you have an agent installed. The directory it writes the config into was being read back as evidence the vendor was there, so ticking an agent once made it look installed forever. Only the agent's own binary counts now.
* The slowest call we make to Stripe carries its own deadline. Every Stripe call was bounded at five seconds, which is right for the checkout path and too tight for an invoice preview.

## 1.1.0 [#110]

Nothing to run if you are already set up. `pushary setup` writes the new skill;
so does opening the Mac app, which carries its own copy.

* A scope boundary now works for a run that changes no files. `propose_scope` takes `promises`: boundaries that are not paths, such as who you will not email, what you will not spend, and which systems you will not open. They are shown to the approver as "Promised, not checked", recorded in the ledger, and never enforced, because the gate judges a file path and these have none. Saying so is the point: the tool used to return `ratified: true` for a marketing or support run whose contract matched nothing.
* The tool now reports what it will actually check. `enforces` lists what the contract *contains* that can be checked, and an empty array means nothing in it is. `hookSeen: false` means no hook has ever reported that session id, so the contract is stored under a key the gate will never read. Both were previously invisible: a contract that enforced nothing looked exactly like one that enforced everything.
* Four glob rules that matched nothing are repaired when they are proposed. `customers`, `docs/`, `**/.env*` and `**/*.test.ts` each validated clean and matched no file. The last two shipped as our own documented examples, so anyone who copied them to protect a root `.env` protected nothing. The missing pattern is added at proposal time rather than by loosening the matcher, which would have widened every contract already live.
* The approval card is budgeted from the restrictive half outwards. The allow list is the only part that grows, so cutting one joined string at the end dropped the off-limits line, the definition of done and the promises first: exactly the half a person needs in order to say no. Agent-supplied text is flattened to one line, so a promise can no longer forge a row the server wrote.
* The editor gates carry the scope path again. The Cursor and VS Code gates contained no reference to it, so approving a breach never widened the contract and every further file in the same area asked again. An over-length value is dropped rather than sent, because `ask_user` caps it and a rejected call fails closed.
* A scope breach says so on the card. A breach judged by the server reached the person as a plain "Allow Edit foo.ts?", with nothing saying a boundary they personally ratified had been crossed.
* `pushary doctor` names a tool that can take your hooks away. cc-switch replaces `~/.claude/settings.json` wholesale when you switch provider, so Pushary stops firing with no error and nothing to see. Doctor says so while the hooks are still there, and says the mechanism rather than blaming it once they are gone. It diagnoses only: it never rewrites a config because somebody else's software is installed.
* The installed skill goes to 0.10.0. It breaks a task into steps before asking anything, settles every fork a file or a command can answer, and asks the rest as one numbered round. A question in the terminal is free and a push is not, so the whole round goes to the terminal when you are there and only the blocking one crosses to your phone. Setup now branches on the machine instead of assuming one path.

## 1.0.0 [#100]

Run `pushary setup` and tick the agents you use. Five more are on the list: Qwen Code, CodeBuddy, Qoder, Droid and Devin CLI. Nothing changes for an agent you already had wired.

* Gate five more agents on their own hooks, not on good intentions. Qwen Code, CodeBuddy, Qoder, Droid and Devin CLI each register the same events Claude Code does, in the file and the spelling that agent uses, and each returns a verdict that agent obeys. Shell commands, writes and edits go through your policy and your phone the same way they always have. Twelve agents are now enforced rather than cooperative.
* Devin answers in its own dialect. It reads `{"decision":"approve"|"block"}` where the others read Claude's `permissionDecision`, so the verdict is written the way each agent reads it. A stop from your phone carries across both: it ends the turn rather than declining one tool call and letting the next one through.
* Two tools are deliberately not claimed on Devin. A question answered on your phone comes back as rewritten input, and Devin's reply shape has nowhere to put it, so asking there would tell the agent "approved" and hand it the question you already answered. Pushary stands aside instead, and Devin asks you itself.
* Read the file out of a patch before judging it. Droid edits by sending a patch rather than a path, and a rule written for a file cannot match a patch body. A single-file patch is now resolved to the file it touches, so `Edit(**/.env)` denies it. A patch over several files is not judged at all and goes back to the agent to ask, because one answer cannot cover several files honestly.
* Never judge a call whose target cannot be read. If a tool names its file under a key Pushary does not recognise, the only rule that could match is the one written for the tool alone, and that is always the looser one. Pushary now says it has no opinion and lets the agent ask you, rather than approving on a rule that was never meant for that file.
* Leave a config alone when it is not the shape Pushary knows. These are five other vendors' files. Where a hook list is something other than a list, setup now names the key, changes nothing and reports the agent as skipped, instead of replacing what it found. It already refused to rewrite a file that would not parse; this is the same care for a file that parses and is simply shaped differently.
* Keep the directory a shell command names. An approval card that said `rm -rf *` without saying where it ran was describing a different command than the one about to happen.

These five rest on each vendor's documentation and our own round trip; no vendor binary was installed to confirm them. If setup reports one as skipped, that is the check above doing its job, and the message names the key it did not recognise.

## 0.99.0 [#0990]

Nothing to run. This release is the part that runs itself: the repairs below happen on the next session start, on the machine that already has them wrong.

* Switch on a hold that an older release registered without its proof. `PermissionDenied` and Codex's `Stop` hold only when their registration carries `--hold-budget`, and a registration written before 0.97.0 is present and looks correct, so nothing noticed it had stopped holding. Until now the repair was `pushary upgrade`, run by hand. Claude Code's registration is now checked on every session start whether or not Claude Code itself has changed, and Codex's is checked on its own session start, which had no repair of any kind before this. An auto-mode block or an auto-reviewer denial can be answered again without anyone being told to run a command.
* Hooks the macOS app wrote are still left to the app, on both agents. It repairs its own, and rewriting them here would point them at a binary the app does not install.
* Read a hold budget that is not this release's as no proof, which is what the Mac app has always done. `pushary doctor` says a hook "carries no current hold budget" rather than that it predates one, because now it can mean either.
* Never replace an absolute path in a hook command with a bare name. When the bin directory cannot be found, which is what a GUI-launched agent or an nvm switch does to `npm prefix -g`, the rewrite is refused and the registration you already have is left alone. A hold that does not hold still works less well than it should; a hook command that no longer resolves does nothing at all, and the rewrite touches every event at once. `pushary upgrade` is a person at a prompt and is unchanged.
* Write Codex's `config.toml` atomically, carrying its permissions over. It is now written from a session-start hook, and two sessions starting at once must not leave it half written. An atomic write replaces the file rather than its bytes, so the mode is copied across by hand: this file holds your API key, Codex creates it private to you, and it stays that way.

## 0.98.0 [#0980]

Run `pushary setup` so the instruction block in Codex's AGENTS.md, GEMINI.md and OpenCode's AGENTS.md carries the new line. `pushary upgrade` rewrites hooks and trust, not instruction files.

* Say the Codex rescue in your own voice. When you allow a command the auto-reviewer denied, the turn now resumes with "I approved this command in Pushary after the auto-reviewer denied it", because Codex hands that text to the model as your own turn. The old third-person wording read as a tool claiming someone else's permission and the model refused to run the command again.
* In the instructions Pushary writes, say that rerunning the exact command you approved after a denial is the approved path and not a bypass of an enforced gate. It sits beside the line that says never to bypass one, which is what the old wording collided with. Tied to the hook result rather than to "when Pushary reports", so a page or a diff reciting the sentence beside a command is not a rule telling the model to run it.
* Register the Cursor gate where it already sits, like every other writer, instead of taking it out and adding a fresh one on the end.
* Drop the Codex trust key of a duplicate of ours when a rewrite collapses it. Otherwise the tool that moves up into that index inherits a hash it cannot match, and Codex reads its hook as Modified and silently stops running it.
* `pushary doctor` no longer says another tool's hook "runs before ours" or "runs after ours". No agent runs the hooks on an event in a defined order, so the line names who else holds the event and for how long, and claims nothing about which goes first.

## 0.97.0 [#0970]

Requires the Codex auto-reviewer handling in `POST /api/agent/gate`, Codex bodies on `POST /api/agent/blocked-action/claim`, the `blocked-action/v2` Claude identity and `sessionCwd` on the gate request before rollout. Run `pushary upgrade` so Claude Code's `PermissionDenied` and Codex's `Stop` are registered with the hold budget, Codex gives `Stop` the full hook budget, and Codex trusts it again.

* When Codex runs with `--approve-for-me`, stop asking you before its auto-reviewer. `PreToolUse` and `PermissionRequest` have no opinion under the reviewer, after the kill switch and a standing deny, so nothing the reviewer allows reaches your phone.
* When the auto-reviewer denies a shell command, hold the turn end and ask once whether to allow that exact command. A yes continues the turn, Codex runs the same command again, and the retry skips the reviewer once. A no, or no answer, lets the denial stand. Denials of `apply_patch` and MCP calls are not asked about yet. The request names the session's directory as well as the command's, so the card can say where the command runs.
* Hold a blocked call only when the hook can prove its host waits that long: the `--hold-budget=<seconds>` argument its registration now carries, or the budget the Mac app hands down in `PUSHARY_HOLD_BUDGET_SECONDS`. The hold never waits past that budget less its reserves. Without proof, which is an install registered before this release, the Claude plugin's older entry, an update that skipped `--finish-upgrade` or a Mac app built before it, a Claude block sends the `Auto mode blocked <tool>` notification instead, and a Codex turn end reads no denial, so it is still asked about once the hook is upgraded.
* Build the `blocked-action/v2` identity for a Claude call, which includes its working directory, so the retry's hint and claim match the server's grant. A Claude call with no working directory is not asked about. Keep the retry hint for the grant's two minutes rather than ten.
* `pushary doctor` warns when a `PermissionDenied` or Codex `Stop` registration carries no hold budget.

## 0.96.0 [#0960]

Requires the auto-mode block handling in `POST /api/agent/gate` and the `POST /api/agent/blocked-action/claim` route before rollout. Run `pushary upgrade` so Claude Code gives the `PermissionDenied` hook the full approval window.

* When Claude Code's auto mode blocks a call, hold the agent and ask once whether to allow that exact call. A yes retries it and the retry runs. A no, or no answer, lets the block stand.
* Stop sending a separate "Auto-mode blocked" notification and remove `PUSHARY_AUTOMODE_RETRY`. The server now decides whether a block is asked about, so the kill switch, a standing deny and your approval mode all apply.

## 0.95.8 [#0958]

* Stop `clean` leaving a key it installed in Claude Code, Codex and Gemini when the Mac app is installed. An entry is kept only when its key is the one the Mac app holds; when the app has never signed in, the key setup recorded is removed.
* Keep `~/.pushary/bridge-auth` when the Mac app is installed. `clean` used to delete the app's bridge key.

## 0.95.7 [#0957]

* Let Gemini's own prompt decide in When I'm out when Pushary cannot create the approval question, instead of refusing the call. Every time still refuses, and says Pushary could not create a verifiable approval.
* Refuse approvals an unattended Gemini bridge cannot show locally with a specific reason (no local input, no phone answer in time, handled on the machine, no device connected), instead of passing them to Gemini's unexplained headless denial.
* Withdraw the phone question before a Codex bridge gives up on a Terminal or Updates question, so an answer that arrives during the withdrawal still counts.
* Describe what happens when you don't answer in `pushary doctor` and `pushary wait` in the current mode words: When I'm out asks your phone when you are away or Pushary cannot tell, then hands back to the agent's own prompt.

## 0.95.6 [#0956]

* Separate synthetic answer tests from real hook activation and report the actual answering surface.
* Cancel known pending diagnostic questions on interrupted or unanswered exits without fabricating approval.
* Add Claude Code activation evidence for a unique scratch-file approval, correlated with the observed tool result.
* Report managed-control readiness separately from hook configuration and phone delivery, refreshing credentials, service state and remote proof after interactive waits.

## 0.95.5 [#0955]

* Preserve the full approval window while allowing the final poll time to return; keep late denials and cancellation authoritative.
* Bundle corrected VS Code read classification and Cursor file-gate fallback, including native shell/MCP prompts when a gate script is missing.
* Share Claude hook ownership with the server to avoid duplicate decisions while retaining native-mode handoff.
* Keep supported-agent setup guidance and policy scope aligned with the shared agent manifest.

## 0.95.4 [#0954]

* Keep inactive/offline login results truthful, with one JSON result and no duplicate key minting to recheck readiness.
* Preserve authentication blocks until readiness is verified; recover the verified saved account while respecting explicit control off.
* Keep setup and CLI help accurate about approval delivery modes.

## 0.95.3 [#0953]

* Verify account readiness after phone pairing before activating approvals or starting managed services.
* Preserve useful configuration while offline, with consistent unverified output and exit codes instead of a successful activation claim.
* Reuse the saved key when setup is rerun after payment or connectivity recovers; preserve explicit phone-start opt-outs.

## 0.95.2 [#0952]

* Add `pushary cowork` and connector-only setup aliases for Claude Desktop, Chat and Cowork, without acquiring a CLI key or installing local hooks.
* Bundle the canonical Cowork skill and expose setup steps, standing instructions and a real user-answer test prompt.
* Explain cooperative connector limits and keep native permission hooks and managed session control separate.

## 0.95.0 [#0950]

Requires the additive session-control and encrypted transcript-preview server routes before rollout.

* Capture opted-in direct Claude terminal transcripts through the daemon, including Mac-owned hooks when this CLI is installed. Normalize explicit Codex rollout paths.
* Keep native terminals open for ordinary phone messages; require explicit phone takeover and resume the verified native session identity.
* Wait for native process exit before SDK control, preserve queued instructions across mode changes, and acknowledge only accepted commands.
* Stream redacted, encrypted SDK text previews using the existing acknowledged session key; completed transcript records remain authoritative.

## 0.94.0 [#0940]

* Align Node compatibility with setup dependencies; unsupported runtimes receive an upgrade message before a command loads.

## 0.93.1 [#0931]

* Attach stable usage report IDs and preserve the report timestamp across retries so the server counts a replay once.
* Report restricted agent-key scope accurately and fail closed on unknown identity scopes.
* Requires the additive server accounting and key-capability changes from #1303 before rollout.

## 0.93.0 [#0930]

Requires Node.js 20.3.0 or newer for shared cancellation signals.

* Register the expanded Claude and Codex hook coverage from the September 4 changes; preserve child-agent identity during compaction.
* Share one deadline across mode lookup, question reconciliation, event reporting, and command acknowledgement. Retain unresolved question markers for retry.
* Deliver queued phone instructions on UserPromptSubmit and keep observational hooks from consuming them.
* Redact credentials in notification activity, phone pushes, and unrecognized failure messages.
* Diagnose modified Codex hook definitions against their installed trust hashes.

## 0.92.1 [#0921]

### A rejected key is an answer, not an empty poll [#a-rejected-key-is-an-answer-not-an-empty-poll]

`pollAgent` returned `{ command: null, mode: null }` for every non-OK response,
so a 401 was indistinguishable from a healthy poll with nothing queued. That
landed on the success branch of `startCommandPoller`, which resets `errorStreak`
to zero, so the backoff never engaged and the wrapper polled a dead key at the
idle cadence forever. Because `mode` was null, `onModeState` never fired, and
`onModeState` is the only place `dualMode` sets `killed` and stops the active
leg. A wrapper whose key the server rejects therefore reported `kill=false` to
itself indefinitely: remote stop could not reach it, phone messages never
landed, and nothing was printed.

`PollResult` now carries `rejected`, set only for 401 and 403, which is the same
line `fetchModeState` already drew between an answer and a blip. A rejected poll
takes the error path, so the existing exponential backoff applies, and the
wrapper prints once that remote stop and phone messages are not active. A 500 or
a dropped connection is still a blip and still retried at the normal cadence.

A rejected response is also no longer trusted for its contents: neither the
command nor the mode state it carries is applied.

## 0.92.0 [#0920]

### A Claude Code upgrade registers the events it just gained [#a-claude-code-upgrade-registers-the-events-it-just-gained]

`CLAUDE_HOOK_EVENTS` gates each hook on the oldest Claude Code that understands
it, and the supported set was filtered by the version detected when the hooks
were written. Nothing re-ran that filter except `pushary upgrade`, so an event
your Claude Code gained reached you when Pushary next shipped rather than when
Claude did: the hook sat in the table, supported by your CLI, and unregistered.

SessionStart now asks the question, because that is the moment an upgrade becomes
observable. The answer costs about 5 ms of local reads and writes nothing unless
the event set actually moved. A machine wired against an older Claude picks up
the newer events on its next session.

It leaves three things alone. Hooks the macOS app wrote are never rewritten: the
app owns that wiring and the CLI's writer would replace its locator with the npm
bin. A patch bump that adds no events refreshes only the receipt, so settings.json
is not rewritten every time Claude Code ships. A machine with nothing wired is
left to `setup`.

The settings write is now atomic — temp file, fsync, rename — because several
sessions can start in the same moment and two plain writes interleaving is a torn
settings.json.

## 0.91.0 [#0910]

### Setup adopts the key the Mac app is already signed in with [#setup-adopts-the-key-the-mac-app-is-already-signed-in-with]

The Mac app authenticates through Clerk and writes its API key into every agent
config it wires, but never into `~/.pushary/config.json`. Setup's key ladder did
not look there, so a Mac the app had already connected still fell through to the
pairing QR and minted a second key for an account that was already live.

The ladder gains one rung between the environment and pairing: a key the Mac app
wrote, probed against the server exactly like the stored and environment rungs
are, and skipped whenever `--key` was passed or `--connect app` was typed. Both
of those still mean what they meant.

## 0.90.2 [#0902]

### The Mac app and CLI coexist without a hook takeover [#the-mac-app-and-cli-coexist-without-a-hook-takeover]

Setup keeps live Mac app hooks in place without prompting, while verifying that
the app and mobile setup belong to the same Pushary tenant. Distinct keys for the
same tenant coexist; a different or unverifiable account is reported without
silently replacing the app's wiring. Stale app hooks are repaired by the CLI.

An explicit `--take-over-hooks` remains reversible. Clean restores the app's
hooks, MCP credentials, and Codex trust from a retry-safe receipt before removing
the CLI, and dry runs no longer claim that restoration already happened.

## 0.90.1 [#0901]

### Daemon logs distinguish health from failure [#daemon-logs-distinguish-health-from-failure]

Successful daemon startup and phone-requested launches now go to the normal log,
leaving the error log for failures that need attention.

### Command-store tests never touch live agent state [#command-store-tests-never-touch-live-agent-state]

The pending command store accepts an explicit directory override. Tests use a
fresh temporary store, so parallel and sandboxed runs cannot read, overwrite, or
prune commands belonging to a real agent session.

## 0.90.0 [#0900]

### A hook that needs an answer is allowed to wait for one [#a-hook-that-needs-an-answer-is-allowed-to-wait-for-one]

Claude Code hooks are now registered at the 600 second budget Claude itself
allows, so a policy that waits two minutes for a phone approval is no longer cut
off at 120 seconds and turned into a denial the user never saw. Anything a hook
does that is not a decision keeps its short timeout.

A phone card is now withdrawn when the tool it guarded completes or the agent's
own client denies it, so an approval cannot arrive for something that already
finished.

### The prompts that never reached the phone [#the-prompts-that-never-reached-the-phone]

Codex permission requests are no longer filtered by a shell matcher, so a browser
use request, a managed network request and an MCP tool request all reach the
phone the same way a shell escalation does. Codex in bypass mode now decides
before the tool runs rather than after it, which is what push-first has always
meant everywhere else.

Gemini reports its turn boundary through AfterAgent and its teardown through
SessionEnd, so a finished Gemini turn is a finished turn rather than a session
that stayed open.

A finished subagent now ends its own session instead of ending its parent's, and
appears under the session that started it. Context compaction is reported as
itself rather than as a tool that ran.

Pushary's own tools are never gated by Pushary, on the server exactly as in the
hook, so asking the user a question can no longer wait on approval to ask it.

### Sessions end, and a daemon that cannot log in says so [#sessions-end-and-a-daemon-that-cannot-log-in-says-so]

A session that goes quiet is closed rather than left standing forever, and the
daemon reaps the sessions it started. `pushary daemon status` lists what it is
holding, how old each one is, and how much memory it is using.

A daemon whose key is rejected now records that and stops, instead of restarting
into the same rejection until something notices. `pushary doctor` says the daemon
needs a login, and logging in clears it.

### Setup and doctor tell the truth about this machine [#setup-and-doctor-tell-the-truth-about-this-machine]

`pushary doctor` names the other tools holding the same agent hooks and how long
each of them waits, checks that the bridge the Mac app installed can be found,
and reports which Node the hooks will actually run under.

`pushary setup` gained `--verify none` for an unattended install, prints what it
would also do during a dry run, offers a way out of pairing, and can take over
hooks another tool is holding with `--take-over-hooks`. `pushary mode` now sets a
site's mode permanently unless told how long to keep it.

### Machine identity and clean [#machine-identity-and-clean]

`pushary clean` leaves the machine identity shared with the Mac app intact, keeps
one entry rather than two, and treats the identity file as the CLI's to own and
the app's to read. Transcript sync seals its recovery ledger and admits a gap
rather than syncing bookkeeping around it.

## 0.89.13 [#08913]

### Synced transcripts survive large turns and restarts safely [#synced-transcripts-survive-large-turns-and-restarts-safely]

Oversized file reads and diffs are shortened before encryption instead of being
rejected by the server, with the removed UTF-8 byte count recorded in the turn.
Stable HMAC identifiers prevent transcript contents leaking through record ids,
and a resumed session reuses its persisted encryption key rather than conflicting
with the key already registered for that session.

Transcript recipients are now pinned on first use and later key changes stop sync
until the user explicitly runs `pushary transcripts trust --rotate`. First use
also fails closed when that pin cannot be stored, so no session key is wrapped to
an unrecorded recipient. New sessions can independently wrap their key for the
owner's phone and an optional audited compliance-recovery recipient; installations
without one remain compatible.

## 0.89.12 [#08912]

### Phone control installs as a native service, without a VM [#phone-control-installs-as-a-native-service-without-a-vm]

Fresh setup enables phone-start when a supported provider and the operating
system's own per-user service manager are available: launchd on macOS, systemd
on Linux, and Task Scheduler on Windows. Existing installs keep their stored
choice. Service replacement is transactional, verifies the new process before
committing, and restores the previous running or stopped state on failure.

Claude Code, Codex and Gemini sessions started from the phone now use the same
supervised control path. Setup checks both the local heartbeat and the server's
view of the machine before calling control ready.

### Fresh and partial installs repair themselves [#fresh-and-partial-installs-repair-themselves]

Setup now verifies every global command, its local JavaScript imports, and the
Cursor and VS Code runtime assets before reusing an installed version. A
same-version package missing any of them is reinstalled instead of failing the
same setup forever. Fresh installs also cover Codex on Windows and recover from
partially configured providers without disturbing unrelated settings.

### The CLI and macOS app keep their own wiring [#the-cli-and-macos-app-keep-their-own-wiring]

Cursor setup writes one gate per event even when the other installer ran first.
`pushary clean` removes the CLI gate while preserving the app's bridge, and
`pushary doctor` validates the MCP entry from the installer that actually wired
Cursor. This keeps mixed CLI/app machines working and avoids false repair
failures on app-only installs.

### Transcript control works in every shell [#transcript-control-works-in-every-shell]

Setup discloses encrypted transcript sync and its audited compliance-recovery
path before enabling it for a new install; older installs remain off until setup
runs again. `pushary setup --transcripts on|off` now provides the same persistent
choice in POSIX shells, PowerShell and Command Prompt. The existing
`PUSHARY_TRANSCRIPTS` environment override remains compatible.

## 0.89.11 [#08911]

### Phone-spawned Codex and Gemini sessions record their conversation again [#phone-spawned-codex-and-gemini-sessions-record-their-conversation-again]

Both bridges relay their turns by default and stop only when told to. The
launchers told them to stop on every run: the value they passed was an equality
test against an environment variable nobody sets, which is false whenever it is
absent and never the "unset" the bridge was looking for. The relay was therefore
never built, and a session started from the phone had nothing to show but its
task title. The opt-out is now passed only when it is asked for.

### An agent standing by stops reading as working [#an-agent-standing-by-stops-reading-as-working]

`pushary claude` and the Gemini bridge reported that a session had started, that
it was still alive, and that it had ended, with nothing in between. Their
heartbeat kept resetting the clock that would otherwise have aged the session out
of "active", so the phone showed a working agent for one that had been waiting at
its prompt since its last reply. That is exactly when someone is looking at the
screen deciding whether to send it something. Both now report the turn boundary
they already detect, as the Codex bridge always has.

### Taking a session over from your phone says so, and is ready when you ask [#taking-a-session-over-from-your-phone-says-so-and-is-ready-when-you-ask]

An instruction from the phone hands the terminal to Pushary so it can drive an
agent that would otherwise sit idle. That has not changed. The handover is now
announced before the session is signalled, instead of the terminal appearing to
lose its agent for no visible reason. The Agent SDK is resolved when the session
starts rather than during the handover, so the wait is gone, and a machine that
cannot reach npm reports the instruction as undelivered instead of accepting it
and then dropping it. An instruction that is dropped now says it was.

## 0.89.10 [#08910]

### Phone control delivery is crash-safe [#phone-control-delivery-is-crash-safe]

Phone instructions now use per-command receipts across polling and relay
delivery. A process restart acknowledges the recorded outcome instead of
silently losing or repeating an instruction, multiple queued commands no longer
overwrite each other, and expired receipts are pruned when new commands arrive.

### Setup and clean reverse only Pushary-owned changes [#setup-and-clean-reverse-only-pushary-owned-changes]

Setup records the Claude and Hermes configuration it replaces. Clean restores
that prior shape without deleting later user edits, and retains the receipt when
service removal, Hermes rollback, or plugin uninstall is incomplete so a retry
can finish safely. Installations created by older releases keep their compatible
best-effort cleanup path.

### Native permission modes keep their intended owner [#native-permission-modes-keep-their-intended-owner]

Codex now reads the permission mode it already reports, and Claude
`PermissionRequest` remains answerable from Pushary after the agent itself asks
for a human. Kill switches and standing denies still take precedence.

## 0.89.9 [#0899]

### Setup proves managed control reaches the server [#setup-proves-managed-control-reaches-the-server]

The background daemon now records successful heartbeats separately from
successful control-queue responses. Setup and upgrade wait for both before
reporting managed control ready, and doctor reports either missing proof.

An authenticated, once-per-minute challenge round trip gives the server the
same readiness evidence without launching an agent or changing queued work.
Machine status exposes that observation additively so current clients keep
their existing fields while newer CLIs can verify capabilities end to end.

## 0.89.8 [#0898]

### Daemon upgrades keep a recoverable service [#daemon-upgrades-keep-a-recoverable-service]

Background-service replacement now records the previous definition and native
running state in an owner-only transaction receipt before changing launchd,
systemd or Task Scheduler. A failed or interrupted replacement restores that
service before another upgrade is attempted, and verifies whether it should be
running or stopped.

Native probe errors are not treated as proof that a service disappeared, and
rollback preserves an administratively disabled service instead of enabling it.

`pushary clean` now proves the background service was removed before changing
agent configuration or local state. If removal cannot be proven, clean stops
with the existing installation intact so it can be repaired and retried.

## 0.89.7 [#0897]

### clean no longer uninstalls the macOS app along with the CLI [#clean-no-longer-uninstalls-the-macos-app-along-with-the-cli]

`clean` removed `~/.pushary` whole. That directory is not only the CLI's: the Mac
app roots its entire runtime there, so the locator every hook execs, the socket
the app listens on, its gate state and its spool all went with it. It also
stripped the app's hook entries out of the agent configs. The app went on
running and went on reporting itself connected, while nothing reached it.

It now removes what the CLI owns and leaves `bin`, `run`, `spool` and `plugins`.
Hook entries are attributed by the command they name, so the app keeps its own.
`disconnect` is unchanged and still disconnects an agent whichever product
connected it.

The `mcpServers.pushary` entry and the VS Code plugin directory cannot be
attributed to either product, so they are kept when the app is installed and
removed when it is not. A CLI-only clean still leaves no API key on disk.

### clean handles OpenCode [#clean-handles-opencode]

setup installs an OpenCode plugin and an MCP entry and `clean` walked past both,
so a command that says it removes all Pushary configuration left the sixth agent
wired. A `pushary.js` somebody else wrote, or one the Mac app wrote, is left
alone.

## 0.89.3 [#0893]

### Doctor recognizes hooks installed by the macOS app [#doctor-recognizes-hooks-installed-by-the-macos-app]

Claude Code, Codex and Gemini hooks that point at the shared native
`pushary-bridge` now pass the same presence, executable and timeout checks as
their npm hook binaries. Doctor no longer tells a Mac-managed install to repair
hooks that are already installed and running.

## 0.89.2 [#0892]

### Multi-question prompts keep their real answer shape [#multi-question-prompts-keep-their-real-answer-shape]

Claude still sends each question separately so older clients can answer it, but
each card now carries its canonical metadata too. Current notch, phone, web and
Slack surfaces keep descriptions, write-in answers and every multi-select value
instead of collapsing a multi-select to one top-level option.

## 0.89.0 [#0890]

### Hermes approvals go to the phone, and setup wires it [#hermes-approvals-go-to-the-phone-and-setup-wires-it]

`setup --agents hermes` now selects Pushary as the Hermes approval transport,
with `transport_fallback: builtin`. Hermes owns the timeout (300s) and the
once/session/always/deny choices, and persists the last two, so a repeated
approval can become a standing rule instead of being asked forever. The
fallback is what makes selecting it safe: a missing key, an unreachable
Pushary, or no connected device falls back to the terminal prompt rather than
blocking work.

The note explaining why setup writes `~/.hermes/config.yaml` directly rather
than running `hermes plugins enable` was half wrong. Current Hermes does
resolve pip-installed plugins in both `list` and `enable`; the reason to write
the file is the rule against executing an agent's binary, and nothing else.

### `pushary upgrade` named a package that does not exist [#pushary-upgrade-named-a-package-that-does-not-exist]

It printed `pip install --upgrade pushary-hermes`. That package is not on PyPI.
The real one is `hermes-plugin-pushary`, and the upgrade path for it is setup,
which installs into the interpreter Hermes actually runs in. Now points there,
like every other agent in that list.

## 0.88.1 [#0881]

### One install, whichever surface writes it [#one-install-whichever-surface-writes-it]

The generated hook spec now describes the whole install, not only the hooks: the
MCP entry for each agent, the managed block in AGENTS.md or GEMINI.md, and the
skill. The CLI writes exactly what it wrote before. The Mac app reads the same
spec, so an install from the app and an install from `pushary setup` leave the
same files behind, and Repair can put back a tool entry as well as a hook.

`Elicitation` is no longer CLI-only in the spec: a typed answer can now come back
from a settlement, so the Mac app writes that hook too.

### One predicate for Ctrl-C at a prompt [#one-predicate-for-ctrl-c-at-a-prompt]

Setup carried its own test for an inquirer cancellation and matched a different
string from the one in `cli/exit.ts`. Both agreed on inquirer's current wording
and would have disagreed the day it changed, printing "Setup failed" over a
deliberate Ctrl-C. One predicate now, matching the union of what both matched.

## 0.87.1 [#0871]

### Unanswered approvals hand off once and fail closed [#unanswered-approvals-hand-off-once-and-fail-closed]

The installed agent instructions now distinguish a live timeout from cancelled,
missing and unavailable questions. They poll once, cancel before moving the
decision into the current client, reconcile the cancellation race once, and stop
when Pushary cannot safely fence the question state.

## 0.86.0 [#0860]

### Approving a plan from your phone [#approving-a-plan-from-your-phone]

Exiting plan mode blocked the terminal and pushed nothing, so an away user's agent
sat waiting on the one approval that decides everything after it. `ExitPlanMode` was
never in the hook's tool matcher, and `plan` is a mode Pushary steps aside for
entirely, so matching it alone would not have helped either.

The plan approval now reaches your phone before Pushary steps aside, and it carries
the plan itself, redacted and capped like any diff, so you are approving something
you can read rather than a bare tool name. Two options rather than the terminal's
three: a hook cannot set the permission mode the session lands in, so offering that
choice would have quietly dropped half of what you picked.

Falls back to the terminal exactly as before whenever the phone cannot answer.

## 0.85.2 [#0852]

### One agent-protocol renderer for CLI and native approvals [#one-agent-protocol-renderer-for-cli-and-native-approvals]

Claude Code, Codex and Gemini hook output now comes from the shared contracts
renderer also used by the native Mac gate. This keeps the CLI wire bytes unchanged
while preventing the native bridge and published hooks from drifting into different
allow or deny shapes.

## 0.85.1 [#0851]

### A rule you wrote is now honoured in auto mode [#a-rule-you-wrote-is-now-honoured-in-auto-mode]

A policy set to deny a tool outright was computed and then discarded in the three
Claude Code permission modes Pushary steps aside for: `auto`, `plan` and `dontAsk`.
`auto` is the default on Pro, Max and Team, so this was most sessions. The native
classifier has never heard of your rule, so it would approve what you had forbidden.

The defer exists to stop Pushary double-prompting on top of Claude Code's own
prompt. A deny prompts nobody, so that reasoning never covered it. A standing deny
now sits with the kill switch, ahead of the defer, and applies in every mode.

Approvals are unchanged: `auto` still defers them, and a tool the classifier
decides to ask about is still reclaimed through `PermissionRequest` and pushed to
your phone. This only closes the case where a rule of yours was silently dropped.

The Codex, Gemini and SDK wrapper paths already behaved this way. This brings the
Claude Code path in line with them.

## 0.85.0 [#0850]

### A hook command that cannot outlive what it points at [#a-hook-command-that-cannot-outlive-what-it-points-at]

Every hook command written into `~/.claude/settings.json`, `~/.codex/hooks.json`
and `~/.gemini/settings.json`, the free bell included, is now wrapped so that a missing binary, a removed
`node`, a changed npm prefix or a moved home directory exits 0 and the agent reads
"no opinion". Before, any of those turned every tool call into a failing hook.
The guard is tested on every shell that can be `/bin/sh`, including dash, and with
`node` off PATH, which used to exit 127 and print on every tool call.

Codex hashes the exact command string to trust a hook, so `pushary upgrade` rewrites
the trust entry when it re-applies the hooks.

### Hooks registered for the CLI you have [#hooks-registered-for-the-cli-you-have]

Claude Code events are registered from a table with a version floor per event.
`SubagentStart`, `SubagentStop`, `PreCompact`, `PostCompact` and `TeammateIdle`
are added on a CLI that understands them, and `pushary upgrade` re-registers
against the CLI you have now. Disconnect removes every event in the table; a
hand-typed list used to leave the five observability events behind.

### `pushary disconnect <agent>` [#pushary-disconnect-agent]

Removes the MCP server, the hooks, the skill and, for Codex, the trust entries and
the API key from `config.toml`, for one agent, leaving the others alone. The bin
map entry was written in a shape the build silently dropped, and the command read
the dispatcher's own token as the agent name; both are fixed before this, its
first release, and a test now holds every bin entry to the one shape tsup builds.

### A kill switch per hook path [#a-kill-switch-per-hook-path]

`~/.pushary/admission-rules.json` (`{"version":1,"disabled":["claude:PostToolUse"]}`)
silences one event on one agent, or one agent entirely, without a release. Every
hook binary reads its input through this check, from the same file the macOS
helper reads, so one file governs both transports. Deny-only: nothing in the file
can enable a hook.

### `PostToolUse` no longer pays two round trips per tool call [#posttooluse-no-longer-pays-two-round-trips-per-tool-call]

The telemetry hooks reuse the mode state the gate fetched for the same session
within the last 60 seconds. The gate itself still reads it live, so a remote stop
and a scope contract are never served stale where they decide anything.

## 0.84.1 [#0841]

### Remote starts survive lost acknowledgements without double-launching [#remote-starts-survive-lost-acknowledgements-without-double-launching]

A phone-started agent now claims exclusive process ownership before the provider
starts. If the daemon restarts or the launch acknowledgement is lost, retrying the
same request reconnects to the existing process instead of starting a second one.

### Repository approval scopes reach Codex and Gemini [#repository-approval-scopes-reach-codex-and-gemini]

Codex and Gemini sessions now carry their repository identity through approval
requests, so repository-scoped rules stay inside the repository that created them.

### Encrypted transcripts retry safely [#encrypted-transcripts-retry-safely]

Transcript writers now retry while a session key is temporarily unavailable and
stop on a real key conflict, preventing undecryptable transcript entries from being
accepted or silently dropped.

## 0.84.0 [#0840]

### The phone can start an agent on a machine that is not running one [#the-phone-can-start-an-agent-on-a-machine-that-is-not-running-one]

The phone could reach a session that already existed. Starting one meant being at
the keyboard. `pushary setup` and `pushary claude` now bring up a small background
process, `pushary-daemon`, which watches for a launch requested from the phone and
starts a real session with the prompt you sent.

It is a poller over a durable queue, not an open socket. Idle, it asks the server
for work every 30 seconds and sends one heartbeat a minute, and it carries a
prompt, never any code. One request is in flight at a time, each bounded by its
own timeout, with a spawn rate cap so a queue backlog cannot fill a machine with
agents. Exactly one daemon runs per machine: a second one asks the first to hand
over rather than racing it, and it declines to take over from a daemon that is
still healthy.

This is a background process that was not running before. `pushary doctor` reports
whether it is up, and `pushary daemon` in a terminal shows you what it is doing.

A launch is now acknowledged rather than assumed. The daemon claims a request,
confirms the session it started, and the phone shows what actually happened,
including the failure when a launch does not come up.

### Always allowing a tool no longer has to mean everywhere [#always-allowing-a-tool-no-longer-has-to-mean-everywhere]

"Approve and always allow" wrote one kind of rule: this tool, this whole
workspace, until you delete it. That is the right scope for `Read` and far too
wide for a push.

The approval now offers the scope alongside it. Workspace is the previous
behaviour. Repository binds the rule to the repository the ask came from, so a
rule written in one checkout stops governing another. Session binds it to the run
you are watching and goes away with it.

An older Pushary never sees the narrower rules. A CLI that does not ask for them
is sent workspace-wide rules only, so a rule you scoped to one session cannot be
quietly applied everywhere by something released before the idea existed.

### AskUserQuestion reaches the phone with its descriptions [#askuserquestion-reaches-the-phone-with-its-descriptions]

A Claude Code question carries a header, a description per option, and sometimes
permission to pick more than one. The phone received the bare labels. It now
receives the question the way the agent wrote it.

One question goes out as one card carrying the whole shape. Every surface that
does not know that shape, the web decision page and Slack among them, still sees
an ordinary choice list and answers with a label, which the server reads back onto
the question. Two or more questions go out one at a time, which is what every
surface has always been able to answer: a bare label cannot say which of several
questions it belongs to, and a half-filled answer is worse for the agent than
being asked again in the terminal.

### Codex and Gemini sessions started from the phone stay live [#codex-and-gemini-sessions-started-from-the-phone-stay-live]

A phone-started Codex or Gemini run now goes through a bridge that survives the
connection dropping and resumes the same session instead of opening a new one.
The machine advertises only what it can actually do, so a Gemini CLI too old for
the bridge is not offered as one, and the phone stops showing controls that would
fail.

Stopping is acknowledged the same way. A stop request names the session and the
process it belongs to, and the machine proves it owns that process before acting
on it, so a recycled pid cannot be mistaken for the agent you asked to stop.

## 0.83.0 to 0.83.2 [#0830-to-0832]

Three releases went out without an entry here. In order: `ask_user` became
idempotent, so a create that gets retried after a timeout resolves to the question
already asked instead of buzzing a phone twice. The pairing QR stopped encoding a
code only a browser could resolve. And the gate's two shared pieces, the verdict a
policy produces and the "most specific rule wins" precedence, moved into the
package the CLI and the server both read, with no change to what either decides.

## 0.82.0 [#0820]

### Setup reads properly when an agent is the one running it [#setup-reads-properly-when-an-agent-is-the-one-running-it]

An agent that runs `setup` relays its output to you, and two things in
that output were written for a terminal that was not there.

Colour was unconditional. Piped into an agent's transcript, ten raw
escape sequences arrived as literal text around the parts you needed to
read. Colour now follows the same rule the rest of the CLI already used,
so it is on at a terminal and off everywhere else.

The app download was unreachable until you gave up. "No app?" was
answered with the command for approving in a browser, which sends you
away from the phone at the moment you were being asked to install it,
and the download link appeared only after the fifteen minute wait
expired. The header now names [https://pushary.com/download](https://pushary.com/download) first and
says the wait continues while you install.

### The pairing QR is smaller [#the-pairing-qr-is-smaller]

The QR encodes a link, and the link's length decides the QR's size. It
carried the pairing id and the public key, 114 characters, which drew 22
rows of blocks. Against a server that offers one, the CLI now uses a
short link instead: 33 characters, 16 rows, and small enough to survive
being relayed through something that truncates.

Nothing depends on it. Against an older server, or if the short link
cannot be issued, setup uses the long one exactly as before, and the
`pushary://` link is never shortened at all.

## 0.81.0 [#0810]

### The idle ping now honours a Terminal mode set in the dashboard [#the-idle-ping-now-honours-a-terminal-mode-set-in-the-dashboard]

"Your agent is waiting" pushes checked your delivery mode by reading the
temporary override only. Choosing Terminal in the dashboard or the app
does not write an override, it writes a standing rule, so the check never
fired and the ping buzzed a phone whose owner had asked not to be reached.

The ping now declares itself a task update, which puts it behind the same
server-side gate as everything else the agent sends unprompted. That gate
sees the standing rule, the kill switch and a mute. It also means your
updates dial governs idle pings: set updates to Off and they stop.

## 0.80.1 [#0801]

### The bell's heartbeat directory is private to you now [#the-bells-heartbeat-directory-is-private-to-you-now]

`pushary bell` counts how many agents are live by keeping one empty file
per session in the system temp directory. On macOS that is already a
per-user directory, so this was fine. On Linux it is the shared `/tmp`,
where it was not: the first user to create `pushary-bell` owned it, and
every other user on the box got a permission error and silently counted
zero agents. Anyone who could write to it could also inflate the count
and trigger the upgrade line.

The directory is now per uid and `0700`, the heartbeats inside it `0600`,
and the sweep judges an entry with `lstat` so a planted symlink is dropped
rather than followed. Nothing about the bell itself changes, and it still
makes no network calls.

## 0.80.0 [#0800]

### A bell, free, for when you only need to know it finished [#a-bell-free-for-when-you-only-need-to-know-it-finished]

`npx @pushary/agent-hooks@latest bell` makes a noise in your terminal and raises
a desktop notification when Claude Code says an agent finished or is waiting on
you. No account, no API key, no network call. Nothing leaves your machine, and
`pushary bell --off` removes it without touching anything else.

If you run one agent, that is genuinely all you need and we would rather you did
not pay for more. Above three agents at once the bell says so, once a day, and
then stops talking, because a bell cannot tell you which of them is asking and
cannot reach you once you have walked away.

If you got here from `claude config set --global preferrednotifchannel
terminal_bell` and the `unknown option '--global'` error, the README now answers
that directly.

### Setup waits for you to tap, instead of trusting that a push went out [#setup-waits-for-you-to-tap-instead-of-trusting-that-a-push-went-out]

Setup used to finish on a delivered notification. A notification that arrives
and cannot be answered looks exactly the same at that point, and that is the
most common way this quietly breaks: approvals keep arriving and keep going
unanswered.

So setup now sends a real question and waits for you to answer it, and only says
`Setup complete, and proven.` once you have. If nothing comes back it tells you
rather than congratulating you. It only does this when someone is actually
there, which includes a pairing you just scanned, and never in CI. Pass
`--verify push` for the old behaviour, or `--verify none` to skip the check.

`pushary doctor --roundtrip` runs the same check and now says the same things
about it.

### Your agent works out when to reach you, without being told [#your-agent-works-out-when-to-reach-you-without-being-told]

The bundled skill used to describe itself only in terms of what you might say to
it: ping me on my phone, run this overnight. That only fires when you are there
to say something. It now also describes the moments that are true of the work
itself: about to do something irreversible, about to spend money or deploy,
blocked on a decision that is not the agent's to make, or a long task finishing
with nobody watching.

Everything it matched before, it still matches. Re-run
`npx @pushary/agent-hooks setup` to update the copy your agents already have.

## 0.79.0 [#0790]

### Your agent now says what kind of update it is sending, so you can route it [#your-agent-now-says-what-kind-of-update-it-is-sending-so-you-can-route-it]

Pushary can now send task updates somewhere different from questions: approvals
can wait at your keyboard while completions still buzz your phone, or the other
way round. That only works if the agent says which one it is sending.

The instructions setup writes now tell your agent to pass a context type when a
task finishes. Without it a completion looks like any other notification, and
the setting you chose for task updates has nothing to act on.

Nothing changes for questions and approvals, and nothing you have configured
needs revisiting. Re-run `npx @pushary/agent-hooks setup` to update the
instructions your agents already have.

## 0.78.0 [#0780]

### Your agent can ask you several things at once, and reach your phone for all of them [#your-agent-can-ask-you-several-things-at-once-and-reach-your-phone-for-all-of-them]

An agent that stops to ask you something often asks more than one thing in the
same breath. Until this release the hook only recognised a single question, so
two or more meant nothing arrived on your phone at all and the whole exchange
waited at the terminal. That is exactly the moment this product exists for.

Up to four questions now come through in turn. The notification says which one
you are on, "(2 of 3)", so the first does not look like the last.

If any question goes unanswered, whether you deferred it, it timed out, or no
device was reachable, the entire exchange goes back to the terminal, including
anything you already answered. A partly filled answer sheet would leave your
agent guessing at questions it never put to you, and being asked twice is better
than being answered wrongly.

The whole exchange shares one wait budget. Four questions do not cost four times
the wait you agreed to.

Questions that let you tick several options at once still go to the terminal.
Those answers travel as a single piece of text and the packing is not something
this release can verify, so it is left alone rather than guessed at.

## 0.77.0 [#0770]

### Stop ends the process [#stop-ends-the-process]

Until this release Stop was a gate verdict. Every pending and new tool call was
denied, which is the guarantee and has not changed, but the agent kept running,
kept thinking and kept spending tokens. For someone who hits Stop because
something is going wrong, "it can no longer act" and "it stopped" are different
promises.

* every session event reports its own pid, so the server can name the process
* the daemon advertises a `stop` capability, which is how the server knows a
  machine can act on one at all
* the daemon applies stops from the drain with SIGTERM, and refuses to signal
  its own pid, since killing itself would take every other session's stop too

Two additive wire changes, both safe in either direction: `pid` on the event
payload, which an older server ignores, and `stops` on the drain response, which
an older daemon ignores.

## 0.76.1 [#0761]

### Actually closing the spawn argv injection [#actually-closing-the-spawn-argv-injection]

0.76.0 shipped under the message "closing the spawn argv injection" and did not.
It sanitised `model` and `cwd` but not `prompt`, and `prompt` is the field the
daemon passes as the token immediately after `-p`, so a flag-shaped prompt was
read back as a flag:

```
['claude','--remote','-p','--permission-mode=dontAsk'] -> {permissionMode:'dontAsk'}
```

`dontAsk` is a full-defer mode, so the gate stopped asking about every tool for
that session.

The server-side rejection landed in production first and is what actually
protects users, 0.76.0 included, with no upgrade required. This release carries
the defence in depth: `buildSpawnLaunch` returns null for a flag-shaped prompt,
so a daemon never builds that argv even if the server is bypassed.

## 0.76.0 [#0760]

### A phone-supplied field could switch your approval gate off [#a-phone-supplied-field-could-switch-your-approval-gate-off]

`pushary claude --remote` sessions started from the phone build their command
line from fields the request supplies. The wrapper then read that command line
back to learn what it had been asked to do, and it scanned every position without
knowing which ones were a flag's **value** rather than a flag.

So a prompt or a model of `--permission-mode=dontAsk` was read as a real
permission mode. `dontAsk`, `plan` and `auto` all defer to the agent's own prompt
unconditionally, which means the session stopped asking you for approvals
entirely, and the decision log recorded a session that was never gated. A clean
approval history that is not true is worse than a missing one.

Flag values are now consumed with the flag that owns them, so nothing a request
supplies can be mistaken for an instruction. A `--permission-mode` you passed
yourself still works, in both the `--permission-mode plan` and
`--permission-mode=plan` forms.

The server that queues these sessions now also refuses flag-shaped model and
working-directory values, so an out-of-date CLI is protected against those two.
It cannot do the same for the prompt, which is free text you are entitled to
start with a dash, so &#x2A;*updating is what closes this one properly.**

Reaching it needed an authenticated session on your own account, spawning to your
own machine, with the daemon running. It is not cross-tenant and not remote code
execution. It matters most where the person spawning is not the person governed:
Team approval routing, Partner, and any case where a phone session or API key has
been compromised.

## 0.75.0 [#0750]

### An agent can now run the install [#an-agent-can-now-run-the-install]

Pasting "install pushary for me" into Claude Code, Codex or Cursor exited 3
before doing anything:

```
! No API key, and no terminal to sign in from.
```

The agent runs setup with stdin and stdout piped, so `isTTY` is false, and app
pairing sat behind the same check as browser login. That check was answering the
wrong question. Pairing needs a person, not a terminal, and the agent shows its
output to one, so a QR written to stdout is read just as well as a QR drawn on a
terminal.

Setup now pairs whenever it is not running in CI. It prints the QR, the tappable
link and the fingerprint, and waits for the scan, so the whole install is one
command with nothing to paste:

```
npx @pushary/agent-hooks@latest setup
```

Browser login still requires a real terminal, because it opens a browser on the
machine and waits for a redirect. CI still declines to pair, so no build hangs
drawing a QR into a log nobody is watching.

The bundled skill told agents to do the opposite: hand the user a signup link
and wait for them to paste a key back. It now says to run setup and show the
user the QR.

The failure message above also had to change, because after this it was naming a
cause that no longer applies. Reaching that branch now means CI, `--skip-phone`,
or a connect mode other than `app`, so setup says which of those it hit instead
of blaming a missing terminal. A headless run with no flags is the one worth
calling out: it used to be told to drop into a browser login it cannot open.

## 0.74.0 [#0740]

### The terminal went quiet while your phone was deciding [#the-terminal-went-quiet-while-your-phone-was-deciding]

A gated tool call sent the push and then blocked, writing nothing. Claude Code
showed a bare spinner. If you missed the notification there was no way to tell
that a question existed, let alone where to answer it, and the terminal prompt
only appeared once the wait expired.

The hook now says so before it blocks:

```
[pushary] Sent to your phone. Waiting 10s, then this terminal takes over.
          Answer here instead: https://pushary.com/dashboard/agent
```

The wait line prints per question, because each question is its own blocking
moment with its own countdown. The URL prints once per session, because it is
the same page every time and repeating it on every gated call is noise.

That URL is the signed-in dashboard, not the `/decide` link the push carries.
The decide link is a bearer credential: anyone holding it can answer. Handing it
to the agent that is being gated would let it approve its own action, so the
hook is only ever told about the page that requires your login.

Servers that predate this send no URL, and the hook just prints the wait line.

## 0.73.0 [#0730]

### Codex could finish setup with no skill installed [#codex-could-finish-setup-with-no-skill-installed]

If your machine already uses skills.sh, setup installs the Pushary skill
through that CLI so the install registers rather than being invisible. For
Codex, `skills add --agent codex` prints "copy to Codex", says "Installation
complete" and exits 0, then writes only `~/.agents/skills/pushary`. Nothing
lands in `~/.codex/skills`, which is where Codex reads. Setup took the exit
code as proof, skipped the copy it ships, and Codex ended up with no skill.

Doctor caught it, and then gave advice that could not work: clean and set up
again reinstalled exactly the same way and failed the same check.

The exit code no longer decides this. What decides it is whether the run left
a SKILL.md where that agent reads, which is the same thing doctor looks at,
and setup writes its own copy when it did not. Anything skills.sh really did
install is left exactly as it installed it, symlinks included.

Everything else about the wiring was fine, so this cost you the skill and
nothing more. Approvals, hooks and the instructions in `~/.codex/AGENTS.md`
were all in place.

### A skill that will not install no longer stops setup [#a-skill-that-will-not-install-no-longer-stops-setup]

The skill is the one piece of the wiring nothing else depends on. It used to
be able to abort setup partway, leaving an agent half configured. Now it warns
and setup finishes the rest, and `pushary doctor` tells you the skill is
missing.

## 0.72.0 [#0720]

### Setup tells you when Codex was already quarantined [#setup-tells-you-when-codex-was-already-quarantined]

0.71.0 stopped setup from getting your Codex binary deleted. This handles the
machines where it already happened. What macOS leaves behind passes every check
setup made: the `codex` on your PATH is a small JavaScript launcher and it
survives, `which codex` still answers, only the binary it launches is gone. So
setup wired up an agent that could not start and reported success.

It now says so before writing anything, and only when it can prove it: a vendor
directory that exists and holds nothing the size of a native binary. A layout it
does not recognise stays quiet, because telling somebody their working install is
broken is the worse mistake. Reinstall with `npm install -g @openai/codex` or
`brew install --cask codex`.

### Setup no longer runs the Hermes binary either [#setup-no-longer-runs-the-hermes-binary-either]

The same hazard, one agent over. When the config edit that enables the plugin
failed, setup fell back to running `hermes plugins enable pushary` — executing a
third-party agent binary, which is exactly what cost people their Codex install.
The fallback also did not work, because `hermes plugins enable` does not see a
pip install. It is gone, and a failed config edit now tells you the one line to
add by hand.

Executing an agent binary is now a build failure rather than a habit: every
source file in this package is scanned on every CI run, and the check knows the
difference between running `codex` and asking `which` where it is.

## 0.71.0 [#0710]

### Setting up Codex no longer gets Codex deleted by macOS [#setting-up-codex-no-longer-gets-codex-deleted-by-macos]

Setup ran `codex --version` to decide whether your Codex was new enough for
native hooks. On macOS, executing a binary hands it to XProtect, and current
definitions false-positive on the Codex CLI: macOS killed it and moved it to the
Trash. Reading a version number destroyed the tool it was asking, mid-setup, and
the only thing you saw was "codex was not opened because it contains malware".

Setup no longer runs Codex, or any other agent's binary, to learn something about
it. The version now comes from the package manifest next to the binary, which
covers npm, bun, pnpm and yarn installs, and from `brew list` for the Homebrew
cask, which ships no manifest. Same result, nothing launched.

## 0.70.0 [#0700]

### A key you name is the key you get [#a-key-you-name-is-the-key-you-get]

Passing `--key` with a malformed value did not fail. Setup read it as no key at
all, went looking elsewhere, and used whichever key it found: one already stored
on the machine, one in your environment, or a brand new one it created by pairing.
You named a credential and quietly got a different one. It now stops and says the
key is not valid.

### setup --json no longer stops to ask a question nobody can see [#setup---json-no-longer-stops-to-ask-a-question-nobody-can-see]

Asking for machine-readable output says plainly that no human is watching, but
setup could still reach an agent-selection prompt. Piped into a script it waited
for a keypress that was never coming, and the prompt drew itself onto the same
output a program was trying to read as JSON. It now selects the agents it detects,
which is exactly what pressing Enter on that prompt would have chosen.

`--json` also promises a single object of output, and every failing exit used to
print nothing at all. A refused key, a cancelled pairing and a crash were
indistinguishable to anything reading the output. Each now says which it was.

### Setup checks its own work [#setup-checks-its-own-work]

An agent installer that finished without an error was reported as configured,
even if nothing had been written. Doctor would then contradict setup minutes
later. Setup now confirms the configuration is really there, using the same check
doctor uses, so the two cannot disagree.

### connect points at the fix that matches your situation [#connect-points-at-the-fix-that-matches-your-situation]

`pushary connect --app` gave one answer for every way a phone can be out of
reach: open the app and allow notifications. That is right when the app is signed
in and the permission was declined, and wrong otherwise. A terminal that was
never paired needs setup. A phone signed in to a colleague's account needs your
account, not a permission toggle. It now says which applies, and when it cannot
tell the two apart it says both rather than sounding certain about the wrong one.

### The editor gates say when a proxy is in the way [#the-editor-gates-say-when-a-proxy-is-in-the-way]

The Cursor and VS Code gates cannot route through a corporate proxy. They still
hand the decision safely to the editor's own prompt, so nothing is blocked, but
every approval quietly stopped reaching your phone with no explanation. When a
proxy is configured they now name it as the likely cause, and on Node 24 or newer
they name the setting that fixes it.

VS Code is also now listed among the supported agents, which it has been since
its plugin shipped.

## 0.69.0 [#0690]

### An approval is never granted on a state Pushary could not confirm [#an-approval-is-never-granted-on-a-state-pushary-could-not-confirm]

When the hook could not reach Pushary, it read that as "you have not been
stopped, and you are under no agreed scope". Those are answers, and not reaching
the server is not an answer. A rule you had set to approve automatically could
therefore fire during an outage on exactly the kind of call a live scope would
have held back.

It now tells the two apart. If the last successful check was under a minute ago,
that answer still stands, so a brief network blip changes nothing, and a stop you
issued moments earlier still stops the agent. Past that, an automatic approval is
withheld and the decision goes to your agent's own prompt instead. Read only
shell commands are unaffected, because that list is decided on your machine and
needs no server at all.

A rejected key is treated as a real answer rather than a blip, so a key you
revoked stops being honoured at once.

### A scope you agreed to is now honoured everywhere, not just in one place [#a-scope-you-agreed-to-is-now-honoured-everywhere-not-just-in-one-place]

Scope was checked when Claude Code asked before running a tool, and skipped on
four other paths that could reach the same decision: Claude's permission dialog,
Codex, Gemini CLI, and the remote wrapper. Each of them fetched the scope you had
agreed to and then ignored it, so the same edit could be waved through depending
only on which route it arrived by. All five now run the same check in the same
order.

### Codex patches are judged on every file they touch [#codex-patches-are-judged-on-every-file-they-touch]

A Codex patch that changes several files at once was judged on the patch as a
whole, so a rule you wrote for one file did not apply when that file was part of
a larger change. Every file is looked at now, and the strictest rule wins. Rules
written as paths also work for Codex and Gemini, which they quietly did not
before.

### Command details that could contain a secret no longer leave your machine [#command-details-that-could-contain-a-secret-no-longer-leave-your-machine]

A command like `GH_TOKEN=... gh pr create` carries its credential in the first
few words, and those words were being sent and stored as the label for what the
agent wanted to do. Notification text was not being cleaned at all. Both are
cleaned now, on your machine and again on arrival, and the Cursor and VS Code
gates clean the command before it is sent rather than after.

### setup --dry-run really does change nothing [#setup---dry-run-really-does-change-nothing]

On a machine with no key, a dry run reached the pairing step, drew a QR code,
waited for your phone, created a real API key, and then said nothing had been
written. It now stops before anything is created and tells you a real run would
connect a key first.

### clean can no longer leave Cursor blocking your commands [#clean-can-no-longer-leave-cursor-blocking-your-commands]

Cursor is told to block a matched command if the Pushary gate cannot answer, and
that list includes ordinary work like rebase, migrate, deploy and publish. Clean
removed the gate's files before removing that instruction, so if the second step
failed, Cursor was left blocking all of them on a file that no longer existed,
under a message saying clean had finished. The order is reversed and checked, and
if the instruction cannot be removed the files stay put, clean says so, and it
exits with an error.

### Pairing survives a dropped reply [#pairing-survives-a-dropped-reply]

If the reply carrying your key was lost in transit, the terminal reported that
pairing had expired and you started again, while the key it never received stayed
on your account. The key is now held until your terminal confirms it has it, so
retrying finishes the pairing you already started. A terminal that cannot reach
Pushary at all now says so instead of sitting under a QR code for fifteen
minutes.

### doctor reports on the agents you actually use [#doctor-reports-on-the-agents-you-actually-use]

Doctor checked Claude Code whether or not you had it, so setting Pushary up for
Codex alone produced a column of failures about software you had never installed.
It now reports on the agents Pushary is set up for, and says plainly when it is
set up for none.

Three things it used to call healthy, it no longer does. A key that lives only in
a shell profile cannot be read by any hook, so an install where nothing could
work was passing every check. A key saved inside Claude, Cursor or VS Code that
no longer matches the one in use, which happens whenever pairing issues a new
one, went unmentioned. And when doctor could not reach Pushary at all, it said
everything was fine.

Its exit codes now distinguish a broken setup from having no phone connected from
not being able to reach Pushary, so a script can tell what went wrong. A test
question nobody answers is now withdrawn instead of sitting on your phone.

## 0.67.0 [#0670]

### The VS Code agent can now ask for approval on your phone [#the-vs-code-agent-can-now-ask-for-approval-on-your-phone]

Setup has a VS Code option. It installs a Pushary agent plugin, connects the MCP
tools so the agent can notify you and ask you questions, and registers a
permission gate so a risky terminal command reaches your phone before it runs.
The policy behind it is the one your other agents already use, so a rule you
wrote for Claude Code applies here too.

Two things about VS Code shaped how this works.

VS Code reads a hook's matcher but does not act on it, so the gate is called for
every tool the agent uses, including reading a file. It therefore decides for
itself, and for anything that is not a risky shell command it returns straight
away without touching the disk or the network.

And a plugin folder does nothing until VS Code is told where it is. Setup adds
that entry to your settings.json. That file usually has comments in it, and
rewriting it as plain JSON would delete every one of them, so an existing file
is edited one line at a time and left otherwise byte for byte identical. If your
settings already have a plugin list with comments around it, setup does not
guess: it prints the single line to paste and names the file.

Unlike Cursor, VS Code hooks cannot ask the editor to block a command on the
plugin's behalf. So when Pushary cannot reach you, or cannot reach its own
server, the gate hands the decision to VS Code's own approval prompt rather than
letting the command through.

`pushary clean` removes all of it again, the settings.json entry included, and
`pushary doctor` checks the three things that can be silently wrong: whether the
plugin is registered at all, whether the gate script resolves, and whether your
key is linked.

## 0.66.0 [#0660]

### Setup waited three minutes for a step that takes longer than three minutes [#setup-waited-three-minutes-for-a-step-that-takes-longer-than-three-minutes]

If you already had the app installed and signed in, pairing resolved in seconds
and this never came up. If you did not, it could not work at all.

Scanning the QR without the app opens a page that sends you to the store. Install
it, sign in, subscribe, come back, scan: that is never three minutes. The CLI had
given up and cancelled the pairing long before, so a first-time user's first scan
was guaranteed to fail, and the only route through was to notice the terminal had
stopped waiting and run setup again.

Setup now waits as long as the code is actually valid, and after the first
45 seconds the spinner says what to do if the app is not installed yet. Ctrl-C
still exits cleanly and cancels the pairing, so nothing holds you there.

The window itself is unchanged in what protects it: a pairing id is 128 bits,
single use, deleted the moment it is claimed, and authorising one requires a
signed-in session for the owning account and the public key you physically
scanned.

## 0.65.0 [#0650]

### The pairing QR now works when you scan it with your phone camera [#the-pairing-qr-now-works-when-you-scan-it-with-your-phone-camera]

It did not. Scanning it opened the app on "Unmatched Route", and the only way
through was the in-app scanner, which parses the QR itself and never routes.

The QR encoded `https://pushary.com/app/pair`, and `/app/*` is claimed by the
app: the AASA lists it and so does the Android manifest. The OS therefore handed
the link to the app before the page could load, which was the intent. What it
handed over was the path `/app/pair`, and the app's pairing screen is `/pair`.
Nothing matched, on every build ever shipped.

The QR points at `/pair` now. Nothing claims it, so the browser always opens it,
and the page hands off to `pushary://pair`, which every shipped build already
routes correctly. That is the whole reason for the move: the Android claim is
compiled into the installed app, so no amount of server or app-store work fixes
the phones already out there, and this does, today.

`/app/pair` still serves the same page, so a link from an older CLI is not dead.

## 0.64.4 [#0644]

### The shell you ran setup in still exported the key it replaced [#the-shell-you-ran-setup-in-still-exported-the-key-it-replaced]

0.64.3 stopped a stale export from hiding the working key on disk, and the rc
file has been rewritten in place since 0.62. Neither reaches the shell you are
standing in: the export there is still the old key, the environment wins over the
config file at hook time, and the agent you start in that terminal a minute later
talks to whichever workspace that key belongs to.

`--connect app` mints on every run and is the command onboarding prints, so this
is the ordinary case rather than an exotic one. Setup now says so under "Still to
do": open a new terminal, or re-export. No key is printed in that line.

## 0.64.3 [#0643]

### A stale shell export hid the working key on disk [#a-stale-shell-export-hid-the-working-key-on-disk]

`PUSHARY_API_KEY` wins over `~/.pushary/config.json`, which is right and
unchanged. But the environment used to win on the key's *shape* alone, so a
well-formed key the server had since revoked shadowed a working one in the config
file and setup exited "This key was rejected by pushary.com" with a perfectly
good key sitting on the machine.

That is the state any shell left open across a key rotation is in: the export is
the old key, the file is the new one, and the terminal you happen to be typing in
decides whether setup works.

The environment key is checked with the server before it is chosen now, and a
rejected one falls through to the stored key rather than ending the run. It costs
no extra call: the verdict is handed to the verification step that was already
making it.

### `--connect app` on a machine with no terminal named the wrong problem [#--connect-app-on-a-machine-with-no-terminal-named-the-wrong-problem]

A headless run that asked to pair said "No API key, and no terminal to sign in
from" even with a key in the config file, because asking to pair deliberately
takes the stored key off the table. It now says the flag needs a terminal for the
QR, and that dropping it uses the key already there.

## 0.64.2 [#0642]

### A run that gave up reported nothing, and said it stopped at the start [#a-run-that-gave-up-reported-nothing-and-said-it-stopped-at-the-start]

`agent_setup_completed` was wired to one of setup's fifteen exits: the last line
of a run that finished. Every other way out returned before it. A key the server
refused, a cancelled pairing, no terminal to sign in from, an installer that
threw, a Ctrl-C at the agent checkbox: all silent. The beacon was added so failed
and abandoned runs would stop being invisible, and the runs it could see were
still only the ones that already worked.

Every early exit reports now, and each says why it stopped: `key-refused`,
`pairing-cancelled`, `no-key`, `login-rejected`, `no-agents-detected`,
`invalid-key`, `interrupted`, `crashed`.

Argv-time exits stay silent, along with `--help` and `--dry-run`. A flag typo is
not an abandoned run: nothing was attempted and nothing was written. It is also
the fastest-failing path there is, and waiting on a beacon took `setup --bogus`
from 60ms to two seconds against an unreachable server. A dry run stays silent
for the other reason: counting it as a completed setup would be its own lie.

`abandonedAt` said where. It was always `start`, because `markStep` had no call
site outside its own test, so the field that was supposed to locate a failure was
a constant. It now moves through the run, per agent inside the configure loop, so
an installer that hangs is named rather than grouped.

Ctrl-C at the pairing QR reports before the process leaves. The cancel and the
beacon run concurrently and the exit waits for both, so this adds nothing to the
worst case a cancel already had.

The beacon authenticates with the key the run resolved rather than the one
already installed. Most of these exits happen before the key is written to disk,
so without that they posted as nobody, which meant the window holding the
interesting failures was exactly the window that could not report.

## 0.64.1 [#0641]

### Ctrl-C at the pairing QR printed nothing [#ctrl-c-at-the-pairing-qr-printed-nothing]

The QR screen said "No app? Press Ctrl-C for the ways to finish without one", and
pressing it printed nothing at all. `connectViaAppPairing` handles SIGINT by
exiting the process itself, so control never returned to setup and the lines it
meant to show were unreachable on the one path that advertised them.

Setup now hands the escape to the pairing wait, which prints it inside the
handler before exiting, and the line on screen names the command directly instead
of telling you to interrupt the program to find out what it is.

The same two commands are printed when a pairing simply never completes, so both
ways out of the QR screen say the same thing.

## 0.64.0 [#0640]

### A typo on `--dry-run` ran a real clean [#a-typo-on---dry-run-ran-a-real-clean]

`pushary clean --yes --dryrun`, one missing hyphen, silently dropped the flag it
did not recognise and performed a full destructive clean: the stored key, the
Cursor plugin, every agent config, and the global package itself. It printed
"Clean complete." with the past tense throughout and exited `0`. The typo most
worth catching was the one on the flag that means "change nothing", sitting next
to the flag that means "do not ask me".

`clean` now rejects a flag it does not know and exits `2` before removing
anything. `--dry-run`, `--yes` and `-y` are unchanged.

### Setup reuses the key this machine already has [#setup-reuses-the-key-this-machine-already-has]

`setup` read `PUSHARY_API_KEY` and never `~/.pushary/config.json`, so the key
`pushary login` had just written was invisible to it. `login` followed by `setup`
in the same shell ran a second browser login and minted a second key, and a
machine with no terminal that had been set up by `login` exited "no API key" with
a working key sitting on disk. The shell export made it work in a *new* shell,
which is what hid it.

Setup now reads the stored key, verifies it, and uses it. A key the server no
longer recognises falls through to a fresh sign-in rather than dead-ending, and a
server it cannot reach keeps the key rather than discarding it.

### The Pushary app is the default connect path [#the-pushary-app-is-the-default-connect-path]

An unflagged `setup` now pairs the app instead of sending you to the browser
subscribe page. `--connect browser` is the fallback for a machine with no app,
`--connect web` is the legacy page and keeps working exactly as before, and
`--connect none` skips the phone step like `--skip-phone`. `auto` and `pwa` are
accepted as input spellings.

Pairing only happens when there is a terminal to show the QR to and no usable key
already on the machine, so re-running setup to add an agent no longer asks you to
scan anything, and no longer mints a key you did not ask for. Typing
`--connect app` explicitly still pairs every time.

When pairing does not complete, setup now names the two ways to finish without
the app rather than only inviting you to try the QR again.

## 0.63.2 [#0632]

### Setup reports what happened, not only that it worked [#setup-reports-what-happened-not-only-that-it-worked]

The setup event fired only when at least one agent had been configured, so a run
that configured nothing, failed, or stopped partway reported nothing at all. The
only visible runs were the ones that already worked.

It now fires once per run whatever the outcome, and carries the connect mode and
its result, how many agents failed, which were skipped, whether the run was
non-interactive, and where a run stopped if it did.

This is the same event that already powers your activity feed, sent with your own
API key to your own workspace. No repo path, hostname or agent content is
included, and nothing is sent before you have a key.

## 0.63.1 [#0631]

### `pushary status --bogus` printed a stack trace [#pushary-status---bogus-printed-a-stack-trace]

An unknown flag on `status` threw where nothing was catching it, so Node printed
a raw stack trace and exited `1` instead of the clean usage error and exit `2`
every other command gives. Other commands were unaffected.

## 0.63.0 [#0630]

### Machines [#machines]

`pushary daemon` now reports itself to your workspace once a minute, and
`pushary status --devices` lists what is there:

```
  Machines
  ● macbook-pro     0.63.0  just now
  ○ build-server    0.62.6  4h ago
```

`online` is worked out from the last heartbeat rather than stored, so a laptop
that closes mid-session reads offline a few minutes later without anything
having to notice it left.

This is what lets a phone start a session on a machine you name, instead of on
whichever one happens to answer first.

Presence is best effort throughout. A heartbeat that fails never stops the daemon
draining its queue, and `status` still reports your key and channels if the
machine list cannot be read. Against a server that predates the endpoint,
`--devices` says so rather than reporting an empty list.

**Needs a database migration** (`0066`). Until it is applied, `--devices` reports
that it could not read the list, and nothing else is affected.

## 0.62.6 [#0626]

### `clean` rewrote your project's Cursor config and left your own alone [#clean-rewrote-your-projects-cursor-config-and-left-your-own-alone]

`clean` built the Cursor MCP path without a home directory, so it resolved
against whatever directory you ran it from. Inside a repo that has a
`.cursor/mcp.json`, it rewrote that committed file, stripping the Pushary entry
and reformatting the rest. Meanwhile your real `~/.cursor/mcp.json` was never
touched, so the API key stayed in it.

Check `git status` in any project you ran `clean` from, and check
`~/.cursor/mcp.json` for a key you thought was gone.

### Every file the CLI touches is now named in one place [#every-file-the-cli-touches-is-now-named-in-one-place]

`setup`, `clean`, `doctor`, `logout` and `upgrade` each derived the same paths by
hand, and they drifted. That drift caused this bug and the `CODEX_HOME` one
before it. All twenty-three call sites now resolve through one module, and a test
fails any command that starts spelling a path out again.

No behaviour changed anywhere else: setup's output is byte-identical across every
mode before and after.

## 0.62.5 [#0625]

### `clean --dry-run` changed things again [#clean---dry-run-changed-things-again]

0.62.4 moved the dry-run guards into their own module and passed the flag in by
value. That happened at module load, before the flag had been parsed from the
command line, so every guard was built in live mode and stayed there. A dry run
stripped the Codex key, rewrote agent configs and removed the plugin directory,
while printing "would" beside each one.

The guards now read the flag when they run rather than when they are built, so
there is no longer an order in which they can be created too early.

If you ran `clean --dry-run` on 0.62.4, treat it as though you ran a real clean:
re-run `setup` to reconfigure.

## 0.62.4 [#0624]

### `pushary clean` crashed partway through on Node 24 [#pushary-clean-crashed-partway-through-on-node-24]

`clean` threw `ERR_INVALID_ARG_TYPE: The "options.force" property must be of
type boolean` and died mid-run, after cleaning some agents and before touching
the rest. Introduced in 0.62.0 by the `--dry-run` work, which started passing
`force: undefined` to `rmSync` on every call that omitted the option. Older Node
ignored that; Node 24 rejects it.

If a clean died on you, re-run it. It is safe to run repeatedly and picks up
whatever is left.

The three mutation primitives behind `--dry-run` now live in `src/cli/dry-run.ts`
instead of inside the command file. Both `--dry-run` defects that reached users
were in those few lines, and both got past tests that could only read the source
as text, because code in `bin/` runs at import and cannot be called by a test.
They are ordinary functions with ordinary tests now.

### The authorize page's code input overflowed its card [#the-authorize-pages-code-input-overflowed-its-card]

The eight character slots were a fixed width, so they added up to 488px inside a
384px card and spilled out of both edges. They now share the row and shrink to
fit, down to a 320px phone.

## 0.62.3 [#0623]

### `setup --connect app --key ...` discarded your key [#setup---connect-app---key--discarded-your-key]

Pairing was checked before the supplied key, so passing `--key` or `--key-stdin`
alongside `--connect app` silently threw that key away and minted a new one. The
key you named stayed live on the account with nothing pointing at it. An
explicitly supplied key now wins, and pairing is only the key source when there
is no key to use.

Pairing still mints a key each time it runs, which is inherent to the protocol.
When that replaces a key this machine was already using, setup now says so and
names the old key, rather than leaving you to find it in the dashboard later. It
does not revoke it for you: the same key may be in use on another machine.

### The update banner offered downgrades [#the-update-banner-offered-downgrades]

Setup compared its version to the registry with `!==`, so it announced an update
whenever the two merely differed. A machine running a build ahead of npm was told
`Update available: 0.62.3 -> 0.62.2` and pointed at a command that would have
downgraded it. It now prompts only when the registry is genuinely ahead, using
the same comparison `pushary upgrade` already used. There is one implementation
of that comparison now instead of two.

### A reused key skipped its own verification [#a-reused-key-skipped-its-own-verification]

Setup skipped the server key check whenever `--connect app` was passed, on the
assumption the key had just been minted. That is only true when pairing actually
produced it, so a key reused on an `--connect app` run was never verified. The
skip now follows where the key came from.

## 0.62.2 [#0622]

### An ignored `--dry-run` made real changes [#an-ignored---dry-run-made-real-changes]

`mode`, `wait`, `suggestions` and `status` read their arguments positionally and
silently discarded any flag they did not recognise. So `pushary mode push_only --dry-run` dropped the flag and changed the mode for real. Those four now reject
an unknown flag and exit `2`, and they do it before looking for your API key, so
a typo is reported as a typo rather than as a missing key.

### The proxy support was never switched on [#the-proxy-support-was-never-switched-on]

`HTTP_PROXY` and `HTTPS_PROXY` handling was written but never called from
anywhere, and Node's fetch ignores both without it. Behind a corporate proxy,
setup verified your key through the one code path that used it, reported
everything healthy, and every approval afterwards failed. It is now installed by
the shared HTTP layer, the MCP transport and the command dispatcher.

### `doctor --json` woke your phone on every run [#doctor---json-woke-your-phone-on-every-run]

The test push was skipped only for `--no-push`. Running `pushary doctor --json`
on a schedule sent a real notification each time. It is now opt-out for a person
at a terminal and off by default for `--json` or a non-TTY. Pass `--roundtrip` to
send one deliberately.

### Browser login could stall on the plan step [#browser-login-could-stall-on-the-plan-step]

Choosing a plan navigated the same tab away from the authorize page, and that
page was the only thing that could finish the login once the plan activated, so
the terminal waited on a promise nothing was going to keep. Checkout now opens in
a new tab and the page completes the login by itself. The CLI no longer claims it
finishes on its own without saying the tab has to stay open.

## 0.62.1 [#0621]

### `pushary clean --dry-run` was not a dry run [#pushary-clean---dry-run-was-not-a-dry-run]

In 0.62.0 the flag ran four real operations while printing "would":

* uninstalled the global `@pushary/agent-hooks` package
* rewrote your shell profile to remove the `claude` alias
* stripped the Pushary block from `~/.codex/AGENTS.md`
* stripped it from `~/.gemini/GEMINI.md`

If you ran `pushary clean --dry-run` on 0.62.0 and the CLI then seemed to
disappear, that is why. Reinstall with `npm i -g @pushary/agent-hooks`, and check
your shell profile and those two files against version control if you keep them
there.

### `pushary upgrade` could destroy `~/.claude.json` [#pushary-upgrade-could-destroy-claudejson]

`upgrade` treated an unparseable config as an empty one and wrote it back, so a
truncated `~/.claude.json` was replaced with nothing but the Pushary MCP entry,
losing every project, MCP server and permission rule in it. A half-written
`~/.claude.json` is what an interrupted write leaves behind, so this needed only
one earlier crash to line up.

A config that cannot be parsed is now left untouched, and the other agent files
are still refreshed around it.

## 0.62.0 [#0620]

### `pushary clean` could leave your API key on disk [#pushary-clean-could-leave-your-api-key-on-disk]

If `CODEX_HOME` was set, `clean` looked for Codex's `config.toml` in `~/.codex`
and never found the real one. It printed `Codex config (not found)`, exited `0`,
and left the key in the file. A user who ran `clean` to remove their key was told
it had worked.

The same fault ran through the rest of the Codex path. With `CODEX_HOME` set:

* `setup` wrote the MCP server, the trust hashes and the notify entry to
  `~/.codex/config.toml` while writing `hooks.json`, `AGENTS.md` and the skill to
  the real `CODEX_HOME`, splitting the install across two directories
* `setup --dry-run` named the relocated path, so the preview and the real run
  disagreed about where the key would land
* `doctor` read the relocated config and reported the key missing
* `logout` treated an exported-but-empty `CODEX_HOME` as a path relative to the
  current directory

If you use `CODEX_HOME`, run `pushary clean --dry-run` to see what is still
there, and check `$CODEX_HOME/config.toml` for a key you thought was gone.

### New [#new]

* `pushary clean --dry-run` lists everything it would remove and changes nothing
* `pushary doctor --bundle` writes a redacted diagnostics file for a support
  thread. Keys, your home directory and the machine name are stripped.
* `pushary logout --revoke` kills the key server-side as well as locally, so it
  stops working everywhere rather than only on this machine

### Changed [#changed]

* `pushary upgrade` now refreshes Codex, Gemini CLI and Cursor, not only Claude
  Code, and names the agents it actually touched. It matters most for Codex,
  whose hooks are trusted by hash: a refreshed hook command without a refreshed
  trust entry is a hook Codex silently declines to run.
* `pushary upgrade` with no global install now names the install modes it can
  see and the command that updates each, instead of one generic line and exit 0
* `pushary daemon` stops on a rejected key or a closed plan and exits `4`
  (`UNAUTHENTICATED`). It used to treat that like a network blip, back off to a
  two-minute poll and sit there under an `online` banner, so a revoked key left a
  daemon that looked healthy and would never launch anything again.
* Ctrl-C during app pairing now cancels the pairing on the server, so a QR still
  on your screen stops being claimable immediately instead of staying live for
  the rest of its five minutes
* `setup` prints the command surface when it finishes

## 0.61.0 [#0610]

The largest release since the CLI shipped. Setup no longer asks you to paste an
API key, the key is checked against the server before anything is written to your
machine, and commands exit with codes that mean something.

### Read this first: exit codes changed [#read-this-first-exit-codes-changed]

Commands that used to print a failure and exit `0` now exit non-zero. If you run
any of these in CI or chained behind `&&`, this is the part that affects you.

| Command                                | Was               | Now      |
| -------------------------------------- | ----------------- | -------- |
| any unknown command or `pushary` typo  | `0`, printed help | `2`      |
| `doctor` with a failing check          | `0`               | `5`      |
| `setup` with a revoked key             | `0`               | `4`      |
| `setup` with an expired or locked plan | `0`               | `5`      |
| `mode`, `wait` with a rejected key     | `0`               | non-zero |
| `status` with no key configured        | did not exist     | `3`      |

The full ladder: `0` ok, `1` failed, `2` usage, `3` not configured,
`4` unauthenticated, `5` problems found, `6` no device, `7` input required,
`8` unreachable, `130` interrupted.

`pushary doctor && deploy` used to succeed against a machine doctor had just
declared broken. That is the change worth knowing about.

### Sign in instead of pasting a key [#sign-in-instead-of-pasting-a-key]

`pushary setup` opens a browser, shows you a code, and receives the key sealed to
a keypair generated on your machine. The key is never pasted, never shown in a
terminal, and never transits in a form the server could read.

* `pushary login` and `pushary logout` as standalone commands
* Pasting a key still works, as a fallback and via `--key`
* `--key-stdin` reads the key from stdin, so it stays out of your shell history
  and out of the process list

### New commands [#new-commands]

* `pushary status` reports what this machine is connected to, with `--json`
* `pushary login`, `pushary logout`, `pushary connect`

### Setup [#setup]

* The key is verified against the server before a single file is written. A
  revoked key or a locked plan stops the run instead of producing a config that
  looks finished and never delivers.
* `--yes` runs setup with no prompts, for CI and images
* `--agents claude_code,codex,...` picks agents without asking
* `--dry-run` prints what it would do and touches nothing
* Agent detection is real, so an agent you do not have is reported as skipped
  rather than counted as configured
* Ctrl-C in a trailing prompt no longer reports the whole run as failed
* A stale `PUSHARY_API_KEY` export in your shell profile is now replaced rather
  than skipped. It used to win forever over a newly rotated key.

### Delivery is proved to your phone, not just to the workspace [#delivery-is-proved-to-your-phone-not-just-to-the-workspace]

Setup and doctor now check that an approval reaches **you**, not merely that
somebody in the workspace has a device. On a shared site where the only reachable
channel cannot be attributed to you, that is said plainly rather than reported as
success.

### Diagnostics [#diagnostics]

* `pushary doctor --json` for one machine-readable envelope
* `pushary doctor --roundtrip` sends a real approval and waits for the tap. It
  works without a TTY, where the old confirm prompt could not run at all.
* `pushary doctor --no-push` for a check that stays silent
* doctor reads the same key the hooks will actually use, honoring
  `PUSHARY_CONFIG_FILE`, and reports a Claude or Cursor config holding a
  different key

### Correctness [#correctness]

* `--help` and `--version` print and exit instead of running the command.
  `pushary daemon --help` used to start a daemon; `pushary hook --help` used to
  block forever on stdin.
* Unknown flags are rejected on the commands that parse them, instead of being
  coerced into a plausible wrong value. `--connect` with an unrecognized mode used
  to silently mean `web`.
* Every file this CLI writes is written atomically, so an interrupted setup can
  no longer truncate a large `~/.claude.json`
* An unparseable agent config is left alone instead of being overwritten
* Files holding your key are created `0600`
* `CODEX_HOME` is honored when locating `config.toml`
* Hermes setup works on Windows
* The Cursor plugin is staged and verified before the old one is replaced
* `installGlobally` pins the exact running version instead of drifting to latest
* `pushary clean` removes only the export line it wrote, not every line in your
  shell profile that mentions the key variable
* Requests honor `HTTP_PROXY` and `HTTPS_PROXY`
* Color honors `NO_COLOR` and `FORCE_COLOR`, and turns itself off when output is
  not a terminal
* `--json` output is machine-readable on stdout, with human text on stderr, so a
  pipe never receives a spinner

### Pairing [#pairing]

The pairing QR now points at a real web page, so scanning it on a phone without
the app installed lands on install instructions for that platform instead of a
dead custom-scheme link.

### Known gaps [#known-gaps]

* `status`, `clean`, `mode`, `wait`, `stats`, `suggestions` and `upgrade` still
  ignore an unknown flag rather than exiting `2`. Unchanged from 0.60.0.
* `pushary upgrade` reapplies Claude settings only. Other agents need `setup`.
* Codex hook trust still uses a fixed version ceiling, so a newer Codex is sent
  to the manual `/hooks` step.