pendingyou 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,130 @@
 # Changelog
 
+## 0.12.0 (2026-10-04)
+
+- The stdio bridge, `pendingyou mcp --app <app>`: a local MCP server for an agent that can't give its MCP client a
+  header from a command (Claude Code's headersHelper, Codex's http_headers_helper), so its `pendingyou` server signs in
+  through this computer's own sign-in all the same, with no second sign-in. The agent runs it by a path that never
+  changes, `~/.config/pendingyou/bin/pendingyou-mcp --app <app>` (`--origin` off production), a small script that finds
+  Node as the headers helper does and runs this version's private copy, so the agent's config never changes on an
+  upgrade. It passes each JSON-RPC line from stdin on to `<origin>/mcp` with the agent's own connection, and each
+  answer back on a line of its own (a JSON body, or each event of a stream), with nothing else on stdout and only a few
+  plain lines on stderr. It keeps the server's session id, sends the protocol version the handshake agreed (and a
+  2026-07-28 request's own headers), starts a session again when the server forgot it, refreshes the sign-in once after
+  a 401 (in the background, as the helper does) and then answers with an error saying to run `npx -y
+  pendingyou@latest init`; Pending You unreachable, a problem on its side, a redirect (never followed: the token goes
+  nowhere else) or a cut-off answer each get a plain JSON-RPC error. It waits for what's under way when stdin closes,
+  and stops at once on SIGTERM. `--check` says which Node runs it. A module asks for it with `bridged` (docs/apps.md
+  has the contract), and init writes the launcher only then.
+- OpenCode (1.17.0 or later; read from 1.18.34's source): `init` finds `opencode` beside Claude Code and Codex and sets
+  it up with the same one approval, as its own connection ("OpenCode on Ann-MBP", a device sign-in with
+  `assistant=opencode` and a client of its own). Its `pendingyou` MCP server runs the bridge, in OpenCode's global
+  config (`~/.config/opencode/opencode.json` or `.jsonc`), edited in place by a small JSON-with-comments editor that
+  keeps every comment and byte around it; a file it can't read or edit safely is left alone, with the entry to add by
+  hand, and a new file gets OpenCode's `$schema`. A remote server at this Pending You that signs in by itself is moved
+  as Codex's is (asked at a terminal, kept with nobody to ask), keeping its `enabled` and `timeout`; one at another
+  Pending You is replaced only once the person says so. `--oauth` writes a remote server instead (`opencode mcp auth
+  pendingyou`). A `permission` that would make OpenCode ask (`"ask"`, or a catch-all rule) gets `"pendingyou_*":
+  "allow"`; a rule of the person's that names Pending You is kept. The skill goes in
+  `~/.config/opencode/skills/pendingyou/SKILL.md`, unless OpenCode already reads the one Claude Code's or Codex's init
+  saved (a second would be a duplicate).
+- OpenCode's plugin, `~/.config/opencode/plugins/pendingyou.js`: one line re-exporting it from this version's private
+  copy, which OpenCode loads at startup. It runs the hooks' script for what it decides: each message carries the
+  hand-off (as a part the model reads and the TUI doesn't show), and a session's first message what a session start
+  says (the setup line while setup isn't finished: `handoff` takes `source` for that); the cards a session posts are
+  remembered (`posted`); a session that goes idle with something for the person left only in chat is asked once to put
+  it on a card, never for the turn its own prompt started, one the person stopped or a subagent's, with a toast saying
+  why; and when a card is answered, a listener per session (`listen --app opencode`, the plugin's child) hands the
+  plugin the wake mod's words, and the plugin starts the turn in that session (`client.session.promptAsync`), idle or
+  busy. The answer itself never leaves Pending You but through `get_request`. Its own prompts carry
+  `metadata.pendingyou`. `init` ends: restart OpenCode (`/exit`, then `opencode --continue`); it finishes setting up the
+  first time you write to it. `status` checks the bridge as OpenCode runs it and with a handshake; `uninstall` gives the
+  config back as it was. Not on Windows yet.
+- Pi (pi.dev, the `pi` command; 0.99.0 or later, whose MCP client came in 0.99.0; read from 1.0.2's source): `init`
+  finds `pi` and sets it up with the others, on the same one approval, as its own connection ("Pi on Ann-MBP"). Its
+  `pendingyou` server runs the bridge, in `~/.pi/agent/mcp.json` (or `$PI_CODING_AGENT_DIR`'s), with `"exposure":
+  "direct"`, without which Pi's model reaches an MCP server's tools only from scripts. Only that member is written,
+  every other byte of the file as it was (a small JSON editor, `json.ts`, that checks each edit by reading it back); a
+  file that isn't JSON, or a `mcpServers` that isn't an object, is left alone, with the entry to add by hand. A server
+  at another Pending You is replaced only once the person says so; one Pi signs in to by itself (`pi mcp login`) is
+  moved on Yes (the default) at a terminal, or `--yes`; one with a command or an Authorization of its own is kept.
+  `--oauth` writes Pending You's address instead, signed in with `pi mcp login pendingyou`, as pi.dev's own client
+  (`oauth.clientRegistration: "cimd"`) from Pi 1.0.1. The skill goes in `~/.pi/agent/skills/pendingyou/SKILL.md`,
+  unless the same stub is already in `~/.agents/skills` (Codex's), which Pi reads too.
+- Pi's extension, in place of hooks (Pi has none): `~/.config/pendingyou/pi/pendingyou.js`, listed in Pi's
+  `settings.json` `extensions` by a path that never changes (upgrading rewrites the file). It runs the hooks' script for
+  Pi: as a session starts (`pickup`, for Pi's next turn), with each message (`handoff`), after Pending You's card tools
+  (`posted --app pi`) and as a run settles (`stopcheck`: a run that left the person something only in chat goes on
+  once). When a card is answered, written back on or its fallback comes due, the listener the extension keeps per
+  session (`listen --app pi`, the same as OpenCode's) hands it the wake mod's words, and the extension starts the turn
+  (`pi.sendMessage`, at once when Pi is idle, after the run when it's busy), never with the answer in it. In Pi's
+  terminal the first session finishes setting up by itself: the session start's setup line starts the turn, once Pending
+  You's tools are there (Pi waits for MCP servers only before a typed prompt), and Pi's line waits 10 minutes after the
+  last, so two sessions reloaded together don't both set up. `init` ends: `/reload` in each Pi session that's open, or
+  start `pi`. `status` checks the bridge as Pi runs it and with a handshake; `uninstall` gives both files back as they
+  were (or takes away the ones `init` made). Not on Windows yet.
+- `hold` inside Pi (which marks its processes `AI_AGENT=pi`, `PI_CODING_AGENT=true`) answers at once: Pi's shell waits
+  for a command to end, so a hold would stop the session for hours. The extension wakes the session anyway; without
+  it, `hold` says to check with `get_request` instead.
+
+## 0.11.0
+
+- One step for the coding agents on a computer (Darin, 2026-10-04): `npx -y pendingyou@latest init` finds Claude Code
+  and Codex (`--app claude-code,codex` names some), says what it found and which it can't set up (an agent too old for
+  it is named, with the version it needs), and sets each up with one approval. Then: restart the agent, and its first
+  session finishes setting up by itself (whoami, report_setup, a test card). Asked for by name and not installed, or
+  nothing found at all: it says so and stops before anyone signs in.
+- One sign-in everywhere: each agent's MCP server signs in through this computer's own connection ("Claude Code on
+  Ann-MBP", "Codex on Ann-MBP"), through the headers helper, on every computer but Windows; 0.10.0 did that only over
+  SSH. The hooks use the same connection, so there's nothing to Authenticate and no second sign-in. Each agent gets a
+  sign-in and a client of its own (`credentials.json`: Claude Code's under the address as before, another agent's under
+  `<address>#<app>`, so a 0.10.0 process still running keeps it; a `.gitignore` of `*` in the folder).
+- Several agents, one approval: a device sign-in each, started together and shown as one link,
+  `/device?code=A&code=B`, which Pending You turns into one consent card naming each agent and the computer, with one
+  Allow (needs Pending You's Worker from this release). On a computer with a browser, the browser opens on it ("Your
+  browser is open on Pending You: press Allow once for Claude Code and Codex (codes …)"); over SSH, the link, a QR code
+  and each code. `--device` shows the codes anywhere, `--browser` opens the browser anyway, `--no-browser` only prints
+  the address. Cancel stops `init` before it changes anything. `login --app <app>` signs one agent in again, with its
+  own client, so it keeps its connection; `login --browser` no longer refuses a connection.
+- Codex CLI (0.152 or later, whose `http_headers_helper` can give Authorization): its `[mcp_servers.pendingyou]` table
+  in `~/.codex/config.toml`, edited in place with every other line as it was, signed in through the helper
+  (`--app codex`) with `default_tools_approval_mode = "approve"`; a stored OAuth sign-in, which would win over the
+  helper, is logged out first. Its skill in `~/.agents/skills/pendingyou/SKILL.md`, and four hooks in
+  `~/.codex/hooks.json`, added after the person's own: a session start (startup, resume, clear), each message, Pending
+  You's card tools, and the Stop check (pattern matching on Codex's final message, once a turn at most). Codex runs a
+  hook only once the person trusts it: `init` says to choose “Trust all and continue”, `status` says which are trusted
+  (from Codex's own hash of each), and `uninstall` keeps the trust of the person's own hooks that move up when ours go.
+  When a card a Codex thread posted is answered, a listener the hooks start for that thread runs `codex queue` in the
+  wake mod's words (never with the answer itself, which other programs could read in its arguments) (Codex 0.157 or later starts a turn on an idle thread; `init` says so on an older
+  one). A server and hooks Codex's `/import` copied from Claude Code are replaced. Not on Windows yet.
+- What happens to a `pendingyou` server that's there is decided before anyone signs in. At this Pending You, signing
+  in by itself (the agent's own OAuth, or the Pending You plugin with no server added by hand): moved to this
+  computer's sign-in without a word where there's no browser, on Yes (the default) at a terminal after saying what
+  that means, or with `--yes`; with nobody to ask, kept, with the command that switches it. Kept, the agent's hooks get
+  a sign-in that only hears, and a kept plugin carries the skill, so none is saved. At another Pending You: replaced
+  once the person says so (or `--yes`); kept, that agent is left as it is.
+- `--oauth`: every agent signs in to its MCP server by itself, as before 0.11.0 (Claude Code's `claude mcp add`; Codex's
+  table without the helper, then `codex mcp login pendingyou`).
+- Finishing setup by itself: a session start (new, resumed or cleared, never a compaction) adds one line while Pending
+  You says the agent's setup isn't finished (hear_answers' `for.setup`, on the request the hook makes anyway): what to
+  call, or that the test card's answer is waiting to be picked up; at most 3 times per `init`, none after 7 days, never
+  once it's verified. `init`'s copy of the wake mod starts that turn itself in Claude Code 2.1.287 or later. `init`
+  ends with the sentence to say when it doesn't, on its own line: “Finish setting up Pending You: it’s connected here
+  already.” (`FINISH_SAY`, the same as Pending You's pages).
+- The hooks run a script with a path that never changes, `~/.config/pendingyou/bin/pendingyou-hook <command> --app
+  <app>`, which runs this version's private copy: upgrading rewrites the script, never the hook lines. Every request a
+  hook or the listener makes names its app (`source`).
+- Node, without the shell's PATH (a Claude Code started from its desktop app or an IDE, Codex's stripped environment):
+  `init` records the Node it ran with by its stable path (`/opt/homebrew/bin/node`, not the Cellar folder an upgrade
+  removes), and the helper and the hooks' script also look in `/opt/homebrew/bin`, `/usr/local/bin` and `~/.volta/bin`.
+  A Mac is named by its own name (`scutil --get ComputerName`) unless `--name` says otherwise.
+- `status` has a section for each agent `init` set up, a `Setup:` line (finished, waiting for the first session with
+  the sentence to say, the test card waiting on you, or answered and being picked up) that never changes Ready, and
+  "no browser here" in its header only when that's true. `uninstall` covers each agent, takes out the shared parts once
+  none is left, says which connections stay on your Assistants page, and ends with how to connect again.
+- `pendingyou mcp --app <app>` is reserved for a stdio MCP server for an agent that can't run a headers helper; it says
+  it isn't ready yet.
+
 ## 0.10.0
 
 - The wake mod: Claude Code 2.1.287 or later is woken when you answer, with nothing waiting in the background. A

package/README.md

@@ -1,51 +1,164 @@
 # pendingyou
 
-Pending You for Claude Code. Your assistants ask you in [Pending You](https://www.pendingyou.com) when you're away;
-this command lets Claude Code hear your answer the moment it's ready, even while it sits idle at the prompt.
+Pending You for your coding agents. Your agents ask you in [Pending You](https://www.pendingyou.com) when you're away;
+this command sets Claude Code, Codex, OpenCode and Pi up to ask there and to hear your answer the moment it's ready,
+even while they sit idle at the prompt.
 
 ```sh
-npx pendingyou init
+npx -y pendingyou@latest init
 ```
 
-Run it once on each computer. It:
-
-- adds the Pending You MCP server to Claude Code for every project (unless it's already there),
-- saves the Pending You skill to `~/.claude/skills/pendingyou/SKILL.md`,
-- signs this computer in (your browser opens once; press Allow; over SSH, a code on your phone instead, as
-  [below](#a-computer-with-no-browser)),
-- adds three hooks to `~/.claude/settings.json`: a new session picks up answers that arrived while nothing was
-  running, your next message brings a waiting answer with it, and a check when Claude Code finishes a turn (below),
-- lets Claude Code start `npx pendingyou hold` and use Pending You's tools without a permission prompt, so a question
-  it asks while you're away doesn't wait on one,
-- keeps a copy of this version for the hooks in `~/.config/pendingyou/cli/<version>/`, so they start in a few
-  hundredths of a second instead of waiting on npx (about half a second each),
-- on Claude Code 2.1.287 or later, adds the wake mod in that copy to `CLAUDE_CODE_PLUGIN_DIRS` (`env` in
-  `~/.claude/settings.json`), so every session is woken when you answer (below). Other folders already there are kept;
-  an older version's copy is replaced.
-
-Your other settings are kept as they are. `npx pendingyou uninstall` removes exactly what `init` added.
-
-Adding the MCP server can take Claude Code a minute or more (it checks its servers); `init` says when it's waiting on
-that. If Claude Code already has a `pendingyou` server pointing somewhere else (staging, say), `init` names both and
-asks before replacing it; `--yes` replaces it without asking, and with nobody to ask it prints the two commands to
-run. Afterwards restart Claude Code, run `/mcp`, choose pendingyou and Authenticate (on a computer with no browser
-there's nothing to authenticate: [below](#a-computer-with-no-browser)).
+Run it once on each computer, in a terminal. It finds the agents on the computer (Claude Code, Codex, OpenCode, Pi;
+`--app` names some), says what it found, and for each one:
+
+- connects it to Pending You through **this computer's own sign-in**: its own connection ("Claude Code on Ann-MBP",
+  "Codex on Ann-MBP" on your Assistants page), which its MCP server and its hooks share, so there's nothing to
+  Authenticate in the agent and no second sign-in,
+- signs them all in with **one approval**: your browser opens on Pending You with one card naming each agent and this
+  computer, and you press Allow once (over SSH: a code and a QR code for your phone, [below](#a-computer-with-no-browser)),
+- adds the Pending You MCP server for every project, signed in through a small helper script (OpenCode and Pi:
+  through a small local bridge, [below](#opencode)), and lets the agent use Pending You's tools without asking each
+  time,
+- saves the Pending You skill (Claude Code: `~/.claude/skills/pendingyou/SKILL.md`; Codex:
+  `~/.agents/skills/pendingyou/SKILL.md`; OpenCode reads either, else `~/.config/opencode/skills/pendingyou/SKILL.md`;
+  Pi reads Codex's, else `~/.pi/agent/skills/pendingyou/SKILL.md`),
+- adds the hooks that hand it your answers: a new session picks up answers that arrived while nothing was running,
+  your next message brings a waiting answer with it, and a check when it finishes a turn catches what it left you only
+  in chat ([below](#nothing-left-only-in-chat)),
+- and wakes it when you answer: Claude Code 2.1.287 or later through the wake mod, Codex through `codex queue`, OpenCode
+  through its plugin and Pi through its extension (which also do the hooks' work there).
+
+Then it says what to do next, and the one sentence to say if it's needed:
 
-If the `pendingyou` MCP server Claude Code uses in a session's folder is another Pending You than the hooks' (staging
-and production, say), both hooks add one line telling Claude Code so, and to ask you which one you use: its cards
-would otherwise go where you don't look. `npx pendingyou status` flags it too. Fix it with `npx pendingyou init
---origin <the one you use>`, then restart the session.
+```
+Next: restart Claude Code here (/exit, then claude --continue), or start it in the folder you work in.
+It finishes setting up by itself and sends you a test card. If it doesn't, say this to it:
+
+Finish setting up Pending You: it’s connected here already.
+```
+
+The first session finishes setting up on its own: it checks in with Pending You, reports what's set up and sends you a
+test card. Claude Code 2.1.287 or later starts that turn by itself; otherwise (and in Codex, after you choose “Trust all
+and continue” for its hooks) the session start adds one line saying what's left, and you say the sentence.
+`npx pendingyou status` says what's set up for each agent, what's missing with the command that fixes it, and how setup
+stands. `npx pendingyou uninstall` removes exactly what `init` added.
+
+Your other settings are kept as they are: `init` merges into Claude Code's `~/.claude/settings.json`, Codex's
+`~/.codex/config.toml` (its `[mcp_servers.pendingyou]` table and nothing else, every other line as it was) and
+`~/.codex/hooks.json`, OpenCode's config and Pi's `~/.pi/agent/mcp.json` and `settings.json` (Pending You's own entry
+in each, every other byte as it was), and running it again changes nothing it doesn't need to.
+
+**A pendingyou server that's there already** is decided on before anyone signs in. One at another Pending You
+(staging, say) is named and replaced only once you say so (`--yes` replaces it without asking); keep it and that agent
+is left as it is. One at this Pending You that signs in by itself (Claude Code's `/mcp` → Authenticate, Codex's
+`codex mcp login`, or the Pending You plugin for Claude) is moved to this computer's sign-in: without asking where
+there's no browser (it can't finish there anyway), on Yes (the default) at a terminal, or with `--yes`; with nobody to
+ask it's kept, and `init` prints the command that switches it. The connection it had stays on your Assistants page for
+you to remove, and answers to the cards it asked through that one won't reach the agent by themselves. A kept plugin
+carries the skill, so none is saved. `--oauth` keeps every agent signing in by itself, as before 0.11.0.
+
+The hooks run a copy of this version kept in `~/.config/pendingyou/cli/<version>/`, through a small script with a path
+that never changes, `~/.config/pendingyou/bin/pendingyou-hook`:
+
+```
+"~/.config/pendingyou/bin/pendingyou-hook" pickup --app claude-code || true
+```
+
+(the path in full). Upgrading rewrites that script, never the hook lines, so Codex, which runs a hook only while you
+trust its exact definition, doesn't ask again. The script runs the copy with the Node `init` ran with, by its stable
+path (Homebrew's `/opt/homebrew/bin/node`, which outlives an upgrade), or the first Node it finds. If the copy can't be
+made (no npm, no network), the hooks run through `npx -y --prefer-offline pendingyou@<version>` instead.
 
 The hooks never get in your way: if anything goes wrong (no network, not signed in, a bad option), they print nothing
 and let your message through. Each one stops within 3 seconds whatever happens, with at most its one-line reminder, and
 never refreshes the sign-in itself: when that's due, it starts the refresh in the background, which finishes on its
-own. Running `init` again updates them in place, and adds any a newer version brings.
+own. Each hands an agent only its own app's cards from its folder, never one another agent posted there.
 
-The hooks run that copy with Node directly, like
-`"/opt/homebrew/bin/node" "~/.config/pendingyou/cli/0.10.0/node_modules/pendingyou/dist/cli.js" handoff || true` (the
-paths in full). If the copy can't be made (no npm, no network), they run through `npx -y --prefer-offline
-pendingyou@<version>` instead. `npx pendingyou status` says which. If you remove the Node they run with, run `init`
-again.
+If the `pendingyou` MCP server Claude Code uses in a session's folder is another Pending You than the hooks' (staging
+and production, say), both hooks add one line telling Claude Code so, and to ask you which one you use: its cards
+would otherwise go where you don't look. `npx pendingyou status` flags it too. Fix it with `npx pendingyou init
+--origin <the one you use>`, then restart the session. Codex's hooks do the same for Codex's server.
+
+## Codex
+
+Codex CLI 0.152 or later (its `http_headers_helper` gives the sign-in; 0.157 or later wakes an idle thread by itself).
+`init` writes, in `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.pendingyou]
+url = "https://www.pendingyou.com/mcp"
+http_headers_helper = "/Users/ann/.config/pendingyou/bin/pendingyou-mcp-headers --app codex"
+default_tools_approval_mode = "approve"
+```
+
+and four hooks in `~/.codex/hooks.json`: a session start, each message, Pending You's card tools (so the Stop check
+knows a turn posted, and so the thread is woken), and the Stop check. **Codex runs a hook only once you trust it**: start
+`codex` and choose “Trust all and continue” (or trust them in `/hooks`). `status` says which are trusted. A
+`pendingyou` server or hooks Codex's `/import` copied from Claude Code (without its sign-in) are replaced.
+
+When you answer a card a Codex thread posted, a small listener `init`'s hooks start for that thread puts a message into
+it with `codex queue`: “Pending You: your person answered “…” (req_…). Call get_request …”, which reads your answer (the
+answer itself never goes in a command's arguments, where other programs could see it). Codex starts a turn at
+once when the thread is open and idle, after the current one when it's working, or when you next open it.
+
+## OpenCode
+
+OpenCode 1.17.0 or later. Its MCP clients can't take a header from a command, so `init` gives it a local server instead:
+the stdio bridge, `pendingyou mcp`, which passes each message on to Pending You with OpenCode's own connection here
+("OpenCode on Ann-MBP"), so there's still one sign-in and nothing to Authenticate. In OpenCode's global config
+(`~/.config/opencode/opencode.json` or `.jsonc`, edited in place with your comments and everything else kept):
+
+```json
+"mcp": {
+  "pendingyou": {
+    "type": "local",
+    "command": ["/Users/ann/.config/pendingyou/bin/pendingyou-mcp", "--app", "opencode"]
+  }
+}
+```
+
+That path never changes: upgrading rewrites the small script there, never OpenCode's config. If your config's
+`permission` makes OpenCode ask (`"ask"`), `init` adds `"pendingyou_*": "allow"` so a question you're away for doesn't
+wait on a prompt; a rule of your own for Pending You's tools is kept. `--oauth` adds `{"type": "remote", "url":
+"https://www.pendingyou.com/mcp"}` instead, which you sign in to with `opencode mcp auth pendingyou`.
+
+And a plugin, `~/.config/opencode/plugins/pendingyou.js`, one line that loads this version's from its private copy. It
+does in OpenCode what the hooks do elsewhere, through the same hooks' script: each message you send carries the
+reminder and any answer waiting (hidden in OpenCode's view, read by the model), a session's first message also says
+what setup has left, a session that left you a question in chat is asked once to put it on a card (with a toast saying
+why), and when you answer a card a session posted, the plugin starts a turn in that session: “Pending You: your person
+answered “…” (req_…). Call get_request …” (never the answer itself). That works while OpenCode is open, idle or busy.
+
+Then restart OpenCode (`/exit`, then `opencode --continue`): it finishes setting up the first time you write to it.
+
+## Pi
+
+Pi 0.99.0 or later (pi.dev, the `pi` command; its MCP client came in 0.99.0). Like OpenCode, Pi runs the bridge as a
+local server, with its own connection here ("Pi on Ann-MBP"). In `~/.pi/agent/mcp.json` (or `$PI_CODING_AGENT_DIR`'s,
+edited in place, everything else kept):
+
+```json
+"pendingyou": {
+  "command": "/Users/ann/.config/pendingyou/bin/pendingyou-mcp",
+  "args": ["--app", "pi"],
+  "exposure": "direct",
+  "description": "Ask your person through Pending You when a decision, fact or step is theirs, and hear their answers."
+}
+```
+
+`direct` puts Pending You's tools in front of Pi's model (Pi's default leaves an MCP server's tools to scripts). Pi asks
+nobody before it runs a tool, so there's nothing to allow. `--oauth` adds Pending You's address instead, which you sign
+in to with `pi mcp login pendingyou` (from Pi 1.0.1 as pi.dev's own client).
+
+Pi has no hooks, so `init` gives it an extension: `~/.config/pendingyou/pi/pendingyou.js`, in the `extensions` of Pi's
+`~/.pi/agent/settings.json`, by a path that never changes (upgrading rewrites the file, never your settings). It runs
+the same hooks' script as a session starts, with each message, after Pending You's card tools and as a run ends (a run
+that leaves you something only in chat goes on once), and when you answer a card a session posted it starts a turn in
+that session, idle or busy: “Pending You: your person answered “…” (req_…). Call get_request …” (never the answer
+itself). In Pi's terminal the first session finishes setting up by itself, once Pending You's tools are there.
+
+Then run `/reload` in each Pi session that's open, or start `pi`. Pi's shell waits for a command to end, so in Pi
+`npx pendingyou hold` answers at once instead of waiting.
 
 ## Nothing left only in chat
 
@@ -78,6 +191,11 @@ card titled “Confirm in Claude Code on <computer>: <step>”, with the exact w
 session's link when Remote Control or Claude Code on the web gives one) and what it'll do then. Only such a message
 costs a request: this folder's open cards, given up after 1.5 seconds.
 
+Codex gets the same two (0.11.0). Its Stop check reads Codex's final message, and whether the turn posted, updated or
+replied on a card comes from Codex's own hook for Pending You's tools in that turn; it asks once a turn at most, for an
+action card titled “Confirm in Codex on <computer>: <step>” when it asked you to type something there. OpenCode's plugin
+and Pi's extension (0.12.0) do the same in theirs.
+
 **On 0.2.0 with another origin?** Its hooks blocked every message (`There's no "--origin" command`). Run
 `npx pendingyou@latest init --origin <url>` again to repair them; see [CHANGELOG.md](CHANGELOG.md).
 
@@ -111,41 +229,37 @@ next message brings any answer with it too.
 When you're at the terminal, Claude Code asks you there and puts the same question in Pending You at once; the
 first answer wins. If you answer in the terminal, it withdraws the card and the hold ends by itself.
 
+**Finishing setup by itself (0.11.0).** In `init`'s copy of the mod, a few seconds after a session you're at opens
+(never `claude -p`), it asks Pending You whether Claude Code is set up here (`whoami`, once Pending You's tools are
+allowed and the server has connected). When it isn't, it starts one turn once the session is idle: “Finish setting up
+Pending You: it’s connected here already.” and exactly what to do. Once per session, in at most three sessions, never
+two within ten minutes, and never again once Pending You says it's set up.
+
 ## A computer with no browser
 
-On a devbox or server you reach over SSH, `/mcp`'s Authenticate opens a browser on that machine, which you can't
-reach. So SSH in, and at the prompt there run:
+On a devbox or server you reach over SSH, an agent's own sign-in opens a browser on that machine, which you can't
+reach. `init` signs in with a code there instead: SSH in, and at the prompt there run
 
 ```sh
-npx pendingyou init
+npx -y pendingyou@latest init
 ```
 
-`init` sees it's an SSH session (or Linux with no display) and signs the machine in with a code instead: it shows the
-code, `pendingyou.com/device` and a QR code of the link with the code in it. Open it on your phone, sign in, check the
-code matches and press Allow. Only allow a code your own computer is showing you. That one approval makes the machine
-a Claude Code connection of its own ("Claude Code on devbox" on your Assistants page), and `init` sets up the rest:
-
-- adds the `pendingyou` MCP server for every project with a `headersHelper` instead of OAuth
-  (`claude mcp add-json --scope user pendingyou '{"type":"http","url":"…/mcp","headersHelper":"…"}'`), so Claude Code
-  signs in through this machine's sign-in and there's nothing to Authenticate,
-- writes that helper, `~/.config/pendingyou/bin/pendingyou-mcp-headers`, a small sh script Claude Code runs each time
-  it connects. It finds Node on PATH, else nvm's default (`$NVM_DIR` or `~/.nvm`), else the Node `init` ran with,
-  runs this version's own copy (never npx), and prints only `{"Authorization":"Bearer …"}`, refreshing the sign-in
-  when it's due,
-- adds the wake mod, the hooks and Pending You's tools to `~/.claude/settings.json` as above, so Remote Control,
-  terminal multiplexers and plain SSH sessions all get them, whatever shell profile they read.
+It sees it's an SSH session (or Linux with no display) and shows a link for your phone, a QR code of it, and each code,
+for every agent it found. Open it on your phone, sign in, check the codes match and press Allow once. Only allow codes
+your own computer is showing you. `--device` shows codes like this anywhere; `--browser` opens the browser anyway;
+`--no-browser` only prints the address.
 
 Run it at an interactive prompt after you SSH in, not as `ssh host npx pendingyou init`: on stock Ubuntu that one-line
-form doesn't read your shell's setup, so nvm's Node and `claude` may not be on PATH. `--device` sets a computer up this
-way wherever it is, and `--browser` uses the browser instead. Then start Claude Code there and ask it to finish
-setting up Pending You. `npx pendingyou status` says what's set up and what's missing, with the command that fixes it.
-If the sign-in ends (30 days, or you remove the machine on your Assistants page), `npx pendingyou login` approves a
-new code and keeps the same connection.
+form doesn't read your shell's setup, so nvm's Node, `claude` and `codex` may not be on PATH. The helper script and the
+hooks find Node anyway when the agents run without your shell's PATH (a systemd service, a terminal multiplexer,
+Remote Control): on PATH, nvm's default, the one `init` ran with, or where Node usually is.
 
 The machine is called by its Tailscale name when Tailscale is installed and running (as `tailscale status` shows it),
-else by its hostname, or by `--name devbox` on `init` or `login`. A cloud's own hostname (AWS's `ip-10-42-1-252`) is
-kept when there's nothing better, and `login` says how to change it: `npx pendingyou login --name <name>` asks for one
-more approval on your phone and renames the connection, which stays the same one.
+else by its hostname, or by `--name devbox` on `init` or `login`; a Mac by its own name (Sharing in System Settings). A
+cloud's own hostname (AWS's `ip-10-42-1-252`) is kept when there's nothing better, and `login` says how to change it:
+`npx pendingyou login --name <name>` asks for one more approval and renames the connection, which stays the same one.
+If an agent's sign-in ends (30 days, or you remove it on your Assistants page), `npx pendingyou login` (`--app codex`
+for Codex's) approves a new code and keeps the same connection.
 
 Only want this command's own sign-in (for `watch`, below)? `npx pendingyou login --device` signs it in with a code,
 hearing answers only, and adds no connection. Your phone asks "Let devbox hear your answers for the assistants running
@@ -170,35 +284,46 @@ more, then skipped. `--once` stops after the first.
 
 | Command | What it does |
 | --- | --- |
-| `init` | Set up Claude Code on this computer (`--no-login`, `--no-browser`, `--device`, `--browser`, `--yes`) |
+| `init` | Set up every agent on this computer (`--app`, `--oauth`, `--no-login`, `--no-browser`, `--device`, `--browser`, `--yes`, `--name`) |
 | `hold <requestId>` | Wait for the answer, print it, exit (`--timeout 4h`); the wake mod answers it itself |
-| `status` | What's set up; exits 0 when Claude Code hears answers right away |
-| `login` / `logout` | Sign this computer in or out (`--device`, `--browser`, `--force`, `--all`) |
+| `status` | What's set up for each agent; exits 0 when each hears answers right away (`--app`) |
+| `login` / `logout` | Sign an agent in again, or out (`--app`, `--device`, `--browser`, `--force`, `--name`, `--all`) |
 | `watch -- <command>` | Run a command each time an answer is ready (`--once`) |
-| `pickup` / `handoff` | The session-start and next-message hooks |
-| `stopcheck` | The Stop hook: items for you left only in chat |
-| `uninstall` | Remove what `init` added, and sign out |
+| `pickup` / `handoff` | The session-start and next-message hooks (`--app`) |
+| `stopcheck` | The Stop hook: items for you left only in chat (`--app`) |
+| `uninstall` | Remove what `init` added, and sign out (`--app`) |
+| `mcp --app <app>` | The stdio bridge: a local MCP server for an agent that can't run a headers helper (OpenCode, Pi), which passes each message on to Pending You with that agent's own sign-in here (`--check`) |
 
-Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`). Options can come
-before or after the command.
+Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`). `--app` takes
+`claude-code`, `codex`, `opencode` or `pi` (several with commas where a command sets up or reports several); with none,
+a command that acts for one agent acts for Claude Code. Options can come before or after the command.
 
 ## What it can see, and where it keeps things
 
-The sign-in only hears answers to your own Claude Code assistants' questions (or, for one made before 2026-10-04, to the one assistant you picked). It isn't an assistant: it can't ask,
-answer or change anything, and it doesn't show up as one. The hooks and `hold` hand a session only the cards its own
-app (Claude Code) posted from its folder, never one Codex or another app posted there. On a computer with no browser it's that computer's Claude
-Code connection instead, which Claude Code asks through, and the hooks hear its answers only. It's stored in
-`~/.config/pendingyou/credentials.json` (readable only by you), refreshes itself, and ends after 30 days or on
-`logout`; `clients.json` remembers which sign-in a computer's connection used, so signing in again keeps it. `state.json` beside it remembers
-which answers were already handed over (ids only), `claude-code.json` what `init` added, and `cli/` the hooks' copy
-of the command line. `init`, `status` and the hooks read `~/.claude.json` (and a folder's `.mcp.json`, and
-`~/.claude/settings.json`'s enabled plugins) only to see whether Claude Code has a `pendingyou` MCP server and where
-it points. Nothing is sent anywhere but Pending You.
+Each agent's sign-in is that agent's own connection on Pending You, signed in from this computer: it can post cards,
+change or cancel its own, read the answers to them and reply in their threads, and it can't answer anything for you.
+The hooks use the same sign-in, and hand a session only the cards its own app posted from its folder. An agent that
+signs in by itself (`--oauth`, or one you kept) gets a sign-in that only hears its answers instead: it can't ask,
+answer or change anything, and doesn't show up as an assistant. They're stored in `~/.config/pendingyou/credentials.json`
+(readable only by you, in a folder with a `.gitignore` of `*` so a dotfiles repository never takes it), refresh
+themselves, and end after 30 days or on `logout`. The headers helper hands an agent's token only to that agent's
+Pending You (Claude Code says which server it's for; Codex's is the one `init` wrote). `clients.json` remembers which
+sign-in each agent's connection used, so signing in again keeps it.
+
+`state.json` beside them remembers which answers were already handed over (ids only) and how many session starts
+reminded an unfinished setup, and when; `claude-code.json`, `codex.json`, `opencode.json` and `pi.json` what `init`
+added; `codex-threads.json`, `opencode-threads.json` and `pi-threads.json` which cards each Codex thread or OpenCode or
+Pi session waits on (ids, names and titles: never an answer); `pi/` Pi's extension; and `cli/` the hooks' copy of the
+command line. `init`, `status` and the hooks read `~/.claude.json` (and a folder's `.mcp.json`, and
+`~/.claude/settings.json`'s enabled plugins), `~/.codex/config.toml`, OpenCode's config and Pi's `mcp.json` only to see
+whether the agent has a `pendingyou` MCP server and where it points. Nothing is sent anywhere but Pending You. OpenCode's plugin reads its session's messages only when it goes idle, for the check that
+nothing was left in chat, and hands the hooks' script just that turn's words and tool names.
 
 The wake mod runs inside Claude Code and reaches Pending You only through the session's own connection, with
-`get_request` on the session's own cards. It keeps each session's cards (id, title, the agent's name, where each
-stands) in Claude Code's store for mods, `~/.claude/plugins/store/`, and forgets them once they close or after 7 days.
-It marks the copy acting for a session in that session's environment (`PENDINGYOU_WAKE_OWNER`).
+`get_request` on the session's own cards (and, in `init`'s copy, `whoami` to see whether setup is finished). It keeps
+each session's cards (id, title, the agent's name, where each stands) in Claude Code's store for mods,
+`~/.claude/plugins/store/`, and forgets them once they close or after 7 days. It marks the copy acting for a session in
+that session's environment (`PENDINGYOU_WAKE_OWNER`).
 
 ## Development