@oar-sh/oar 0.9.6 → 0.9.7

package/CHANGELOG.md

@@ -5,6 +5,178 @@ All notable changes to OAR are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.9.7] — 2026-10-03
+
+Highlights: Claude Cloud chats (experimental, off by default) run Claude Code
+in a sandbox at Anthropic on a GitHub repository; conversations can be
+archived and have a context menu in the list; agents can start and use
+sessions on the relay they run on; commits of Claude sessions say "Open
+Agent Relay"; Check Usage opens at once.
+
+### Added
+
+- **Archive conversations, and a context menu in the list.** Every
+  conversation row has an **Archive** button beside Delete (and the chat's
+  `⋯` menu an **Archive conversation** entry). An archived chat leaves the
+  list and its session worker is stopped; the 🗄 toggle at the top of the
+  sidebar shows the archived chats, each with **Unarchive**. A Claude Cloud
+  chat's cloud session is archived and unarchived at Anthropic with it. A
+  message into an archived chat (an agent's, say) brings it back by itself;
+  the composer of an archived chat says so instead of sending. A right-click
+  on a row — a long press on a phone — opens a menu with Open, Edit title,
+  Stop turn, Kill session, Archive/Unarchive and Delete.
+- **Commits made from OAR say so.** Claude sessions now end their commit
+  messages with `Co-authored-by: Open Agent Relay (<model>) <no-reply@oar.sh>`
+  — the model's name in the parentheses, e.g. `Claude Fable 5.1` — and pull
+  request bodies with `🤖 Generated with [Open Agent Relay](https://oar.sh)`,
+  instead of Claude Code's own lines. Settings → Providers → Claude has the
+  choice: **OAR** (the default), **vanilla** (Claude Code's own attribution)
+  or **off** (none); a repo folder can override it from the 🧠 context modal
+  of any of its Claude sessions. A change reaches running sessions with their
+  next message. Claude Cloud chats follow the same setting: the sandbox gets
+  it with the first message and again when it changes, and in OAR mode the
+  `Claude-Session` link is left out of the commit as well. Other providers
+  are not touched: their tools have no such setting.
+- **Claude Cloud (experimental): chats that run in a sandbox at Anthropic.**
+  A new provider, off by default. A Claude Cloud chat runs Claude Code in
+  Anthropic's cloud, on its own clone of a GitHub repository instead of on
+  the relay host. It is billed to the Claude account the host's Claude CLI
+  is logged in to, and its results come back as branches the agent pushes.
+  Switch it on in Settings → Providers → Claude Cloud and choose the cloud
+  environment and a default model there; it needs the Claude CLI logged in
+  with a claude.ai account on the relay host, GitHub connected to that
+  account, and the Claude GitHub app allowed on the repository.
+  - **New Chat** fills **Repository** and **Branch** from the folder you
+    pick, offers the repositories the Claude GitHub app can reach (the ones
+    used here before first) and the branches of the picked repository, lets
+    you type both, and warns about commits that are not pushed, changes
+    that are not committed and a repository the app cannot reach.
+  - **In the chat** the reply streams in live, the agent's questions and
+    permission prompts arrive as cards, **Stop** interrupts the turn, images
+    can be attached, and the model can be changed between turns. A line
+    above the composer links the session on claude.ai and every branch the
+    agent pushed to its comparison on GitHub, and shows the cost so far.
+  - **Turns** survive a restart of the worker or the relay without sending
+    your message twice. A turn stays open while the agent's background work
+    runs, a turn the session starts by itself (after long background work,
+    or from a message sent on claude.ai) appears as a reply of its own, and
+    a turn refused at the usage limit is paused until the reset like a
+    local Claude turn.
+  - **Commits** follow the relay's attribution setting (see above), and
+    deleting or archiving the chat archives the cloud session.
+  - **Not there:** relay modes, a reasoning effort, steering during a turn,
+    files other than images and anything else from the relay host, and the
+    relay's tools and previews inside the sandbox.
+  - **Before you switch it on:** the provider uses the Claude CLI's stored
+    login to call the Anthropic API endpoints the CLI itself uses. These
+    are not a documented public API and may change. OAR only reads the
+    token: it never stores or logs it and sends it nowhere but to
+    Anthropic; when it has run out, OAR lets the CLI refresh it. While the
+    provider is off the relay fetches nothing with that login, except for
+    cloud chats you created before. See "Claude Cloud" in the README.
+    `scripts/claude-cloud-live-check.mjs` checks a running relay's Claude
+    Cloud end to end.
+- **Check Usage: live Claude limits and a Claude Cloud card.** With Claude
+  Cloud switched on, the Claude card reads the 5-hour, weekly and per-model
+  limits live from the account when you open the modal, instead of showing
+  the reading of your last Claude turn, and a limit that is getting close
+  carries Anthropic's warning. The card also shows which product the week
+  went to (Claude Code, chats and the others) and the organisation's prepaid
+  credits. The new Claude Cloud card shows the account's cloud credit (used,
+  left, and when it expires) and what the cloud chats on this relay have
+  cost as Anthropic reports it, in total and for the chat you opened the
+  modal from; a credit that is offered but not yet claimed is mentioned with
+  a link. The limit-reset vouchers (full reset, 5-hour reset) stay
+  claude.ai-only: no endpoint the CLI's login reaches carries them, so the
+  card links to the usage page instead. With Claude Cloud off, the Claude
+  card is what it was.
+- **Agent sessions: an agent can hand parts of its task to other sessions on
+  the same relay.** The `remote_relay` tool now also works on the relay the
+  agent runs on: it starts sessions there, waits for them and reads their
+  replies, and each one is an ordinary conversation in your list. Off by
+  default; switch it on in Settings → Relays → Agent sessions (**Agents may
+  start and use sessions on this relay**). No relay has to be paired. The
+  first time the agent of a conversation starts a session, a card asks you
+  once for that conversation. At most 4 sessions it started may be at work at
+  the same time, a session that an agent created cannot start sessions
+  itself, and an agent cannot prompt, stop or archive the conversation it
+  runs in. A session can use any provider that is enabled on the relay
+  (image chats excepted); a Claude Cloud chat is started with the new `repo`
+  and `branch` arguments, and an agent on a paired relay can now start a
+  cloud chat here the same way. Sessions an agent starts use this relay's
+  accounts, show **via agent** with the title of the conversation they came
+  from in the sidebar and the header (a click opens it), and are never
+  archived automatically. The new
+  **Longest wait per tool call** slider in the same place sets how long one
+  call may wait for a reply: 10 minutes as before, up to 60; it applies to
+  waits on paired relays too. See "Agent sessions" in the README.
+
+### Changed
+
+- **Check Usage opens at once.** The modal shows the reading it showed last
+  time immediately and reads only the open tab's provider live (the card says
+  "updating…" meanwhile), instead of fetching every provider and showing a
+  spinner until the slowest answered. A tab you switch to is read live when
+  its reading is older than a minute; **Refresh** reads the open tab only.
+  The relay keeps the last live answer of every provider, so the other cards
+  stay filled (`GET /api/usage?providers=…`).
+- **Windows: the relay no longer stops while it reads the process list.**
+  Before every launch, every kill and every check of a worker that went
+  quiet, the relay reads the list of all processes through PowerShell. It
+  did so synchronously: half a second to a second and a half on an idle
+  machine, several seconds under load, during which the relay answered
+  nothing — under CI load that was enough for the tunnel to report 502 for
+  the whole relay. The list is now read off the relay's thread; callers that
+  ask at the same time share one read, and a read is reused for 1.5 s. A
+  worker that went quiet is checked by its pid first and by the list last.
+  `GET /api/status` → `sessionWorker.processList` shows when the list was
+  last read, how long it took and whether it failed; a read slower than two
+  seconds is logged. A kill or a workspace relaunch that cannot read the
+  list answers 409 with the reason instead of failing with 500 or stopping
+  blind.
+
+### Fixed
+
+- **A reply that names an error code is a reply.** A reply a session
+  worker published was read as a failed turn when its one paragraph led up
+  to "Error code: relay.…" — a short report on a test that had failed with
+  that code, for instance. Workers always send the failure as a record, so
+  their replies are no longer read for one; the page's fix buttons under a
+  failure follow the same rule and no longer appear under a reply that
+  mentions a code in a quotation, a code span, a table or a list.
+- **Two prices in one paragraph were shown as a formula.** In a reply such
+  as `this run cost $4.20, the earlier one $3.80`, everything between the
+  two dollar signs was rendered as maths. A dollar sign now starts a formula
+  only when it is written the way inline maths is: no space after the
+  opening sign, no space before the closing one, and no digit right after
+  it. Prices stay text; `$x^2$` is still maths. A wide inline formula also
+  no longer makes the whole message scroll sideways: it stays inside the
+  bubble and scrolls within itself.
+
+- **Windows: no worker could start once an agent had run a command with an
+  arrow or a bullet in it.** Before every launch the relay reads the list of
+  all processes through PowerShell. Under the console's OEM code page
+  PowerShell wrote characters such as `→` and `•` as control bytes, the list
+  stopped being valid JSON, and every launch on the relay failed: each session
+  you wrote to turned yellow after six tries and stayed so, for every
+  provider, until the relay was restarted. The list is now written as UTF-8, a
+  control byte that still gets through is tolerated, a list the relay cannot
+  read no longer stops a launch, and a session whose launches were exhausted
+  is tried once more every minute instead of waiting for a restart.
+- **A session whose worker cannot be started now says so.** Until now such a
+  session showed a yellow dot and nothing else. The relay now writes one note
+  into the conversation — why the worker could not be started, in one
+  sentence plus the cause — and keeps that same note up to date: it tries
+  again every minute for ten minutes, then stops and the note gets a
+  **Retry** button for once the cause is fixed; when the worker starts, the
+  note says so. Your message stays queued the whole time, and a queued
+  restart of the relay no longer waits for a message the relay has stopped
+  trying to deliver.
+- **The Claude usage card showed extra-usage credits 100 times too high.**
+  Claude reports these amounts in the currency's minor units (cents), and
+  the card showed them as dollars: 12.50 used of a 50.00 limit read as 1250
+  of 5000. The percentage was right.
+
 ## [0.9.6] — 2026-09-29
 
 Highlights: a Claude turn pauses at the usage limit and carries on after the

package/README.md

@@ -8,13 +8,14 @@ curl -fsSL oar.sh/install | sh
 
 On Windows, run `irm oar.sh/install.ps1 | iex` in PowerShell. Landing page: [oar.sh](https://oar.sh). npm and git-checkout installs are covered under [Install](#install).
 
-OAR relays six runtimes: **GitHub Copilot**, **OpenAI (BYOK)**, **OpenAI Image (BYOK)**, **Claude (Agent SDK)**, **Cursor (Agent SDK)**, and **Grok (CLI ACP)**. You pick one per conversation, and all of them share the same chat UI, queue, history, file browser, and question cards.
+OAR relays seven runtimes: **GitHub Copilot**, **OpenAI (BYOK)**, **OpenAI Image (BYOK)**, **Claude (Agent SDK)**, **Claude Cloud**, **Cursor (Agent SDK)**, and **Grok (CLI ACP)**. You pick one per conversation, and all of them share the same chat UI, queue, history, file browser, and question cards.
 
 ```text
                                              ┌── Copilot       SDK worker, or Copilot CLI + extension
                                              ├── OpenAI        Copilot runtime, your API key
-[Browser] <--WebSocket--> [OAR relay :3333]  ┼── OpenAI Image  Images API, called by the relay
-                                             ├── Claude        Agent SDK worker, host's Claude login
+                                             ├── OpenAI Image  Images API, called by the relay
+[Browser] <--WebSocket--> [OAR relay :3333]  ┼── Claude        Agent SDK worker, host's Claude login
+                                             ├── Claude Cloud  sandbox at Anthropic, host's Claude login
                                              ├── Cursor        Agent SDK worker, your Cursor API key
                                              └── Grok          Grok CLI over ACP, host's Grok login
 ```
@@ -65,6 +66,7 @@ You need Node.js plus whatever the runtimes you actually use need. Nothing else
 | GitHub CLI (`gh`), signed in | the `oar` launcher command; Extension-engine sessions on Windows; the Copilot card in **Check Usage** | `gh copilot` is built into current GitHub CLI releases, so there is no extension to install. The usage card also accepts a token in `GH_TOKEN` or `GITHUB_TOKEN` |
 | OpenAI API key | OpenAI and OpenAI Image chats | Entered in **⚙️ Settings**, stored in the relay database |
 | A Claude login on the relay host | Claude chats | Log in from **⚙️ Settings → Providers → Claude → Relogin** (the panel can install the Claude Code CLI first), or run `claude` once on the host. The relay stores no Claude key |
+| The same Claude login, from a claude.ai account with GitHub connected | Claude Cloud chats | The Claude GitHub app must be allowed on each repository a cloud chat works on (see [Claude Cloud](#claude-cloud)) |
 | Cursor API key | Cursor chats | Entered in **⚙️ Settings**, stored in the relay database |
 | Grok CLI, signed in | Grok chats | Install it and sign in from **⚙️ Settings → Providers → Grok**, or set `XAI_API_KEY` in the relay's environment |
 | tmux (optional) | Linux and macOS | Session workers run in detached tmux sessions you can watch from the browser (**🖥️ Inspect tmux console**). Without tmux they run as plain background processes |
@@ -172,9 +174,9 @@ A global install keeps its state in `~/.oar` (`%APPDATA%\oar` on Windows; `OAR_S
 
 ## Runtimes
 
-The runtime (called the *provider* in the UI) is chosen in **New Chat** and then fixed for that conversation: once a conversation has sent its first message it keeps that provider, and its composer is locked to that provider's models. The composer states this above the input — `🔒 Session locked to GitHub Copilot / OpenAI / OpenAI Image / Claude SDK / Cursor SDK / Grok models.`, colour-coded per provider. OpenAI sessions also pin one exact model, which the note names in parentheses and the model dropdown shows as a disabled `🔒` entry.
+The runtime (called the *provider* in the UI) is chosen in **New Chat** and then fixed for that conversation: once a conversation has sent its first message it keeps that provider, and its composer is locked to that provider's models. The composer states this above the input — `🔒 Session locked to GitHub Copilot / OpenAI / OpenAI Image / Claude SDK / ☁ Claude Cloud / Cursor SDK / Grok models.`, colour-coded per provider. OpenAI sessions also pin one exact model, which the note names in parentheses and the model dropdown shows as a disabled `🔒` entry.
 
-Turning a provider **off** (or removing the OpenAI key) rebinds conversations that have not sent a message yet back to Copilot, so you are never left with a conversation pointing at a runtime that can no longer start. Conversations already in flight, and conversations belonging to a different provider, are left alone.
+Turning a provider **off** (or removing the OpenAI key) rebinds conversations that have not sent a message yet back to Copilot, so you are never left with a conversation pointing at a runtime that can no longer start. Conversations already in flight, and conversations belonging to a different provider, are left alone. Claude Cloud is the exception: switching it off only takes it out of **New Chat**, and its conversations stay as they are.
 
 | Runtime | Enable via | Auth | Notes |
 | ------- | ---------- | ---- | ----- |
@@ -182,6 +184,7 @@ Turning a provider **off** (or removing the OpenAI key) rebinds conversations th
 | **OpenAI (BYOK)** | ⚙️ Settings → Providers → OpenAI | your API key, stored in the relay database | Runs the Copilot runtime, on either engine, against an OpenAI-compatible endpoint |
 | **OpenAI Image (BYOK)** | ⚙️ Settings → Providers → OpenAI | the same key | The relay calls the OpenAI Images API itself; a chat whose replies are images |
 | **Claude (Agent SDK)** | ⚙️ Settings → Providers → Claude | the relay host's Claude login, **switchable from the panel** | A dedicated Node worker per conversation. The Claude Code CLI can be installed and updated from the panel |
+| **Claude Cloud** | ⚙️ Settings → Providers → Claude Cloud (off by default) | the relay host's Claude login (a claude.ai account), read from the Claude CLI | Claude Code in a sandbox at Anthropic, on a clone of a GitHub repository. Results come back as pushed branches; billed to that Claude account. Uses API endpoints that are not a documented public API (see [Claude Cloud](#claude-cloud)) |
 | **Cursor (Agent SDK)** | ⚙️ Settings → Providers → Cursor | your Cursor API key, stored in the relay database | A dedicated Node worker per conversation through the Cursor Agent SDK |
 | **Grok (CLI ACP)** | ⚙️ Settings → Providers → Grok | the relay host's Grok CLI login, **sign in and out from the panel** | Drives the Grok CLI's `grok agent stdio` over ACP. The CLI can be installed and updated from the panel |
 
@@ -214,6 +217,8 @@ Save your key in **⚙️ Settings → Providers → OpenAI**, together with the
 
 Turn on **⚙️ Settings → Providers → Claude → Enable Claude for New Chat model selection**. The relay authenticates through the Claude credentials on the host machine (`~/.claude`), so there is no key to enter.
 
+**Commit attribution.** Commits an agent makes in a Claude session end with `Co-authored-by: Open Agent Relay (<model>) <no-reply@oar.sh>` — the model's name in the parentheses, e.g. `Claude Fable 5.1` — and pull request bodies with `🤖 Generated with [Open Agent Relay](https://oar.sh)`. The same tab has the choice: **OAR** (default), **vanilla** (Claude Code's own `Co-Authored-By: Claude …` lines) or **off** (no attribution). A repo folder can override it for all of its Claude sessions from the **🧠** context modal. A change reaches a running session with its next message (a switch back to vanilla restarts the session's CLI between turns). [Claude Cloud](#claude-cloud) chats follow the same setting. Other providers are not affected: their tools have no such setting.
+
 The same panel manages the account itself. The row at the top names the signed-in account and plan, and:
 
 - **Relogin** runs the Claude CLI's login on the relay host and brings the flow to the browser: the authorize link appears inline with a **Copy link** button — open it on any device, authorize on claude.ai, then paste the returned code back into the field. The relay holds no Claude secret; the CLI rewrites the host credentials, and a fresh model discovery runs straight after, so switching accounts needs no relay restart. The flow is pushed over the socket, so you can start it on one device and finish it on another, and closing the modal does not lose it.
@@ -240,6 +245,69 @@ Differences from Copilot conversations:
 - Claude turns are not included in the Copilot usage line, and no usage line is attached to their replies (Claude's own plan limits appear in **Check Usage**)
 - The browsable **Session** root points at the Agent SDK's project directory rather than a Copilot session-state folder
 
+### Claude Cloud
+
+**Experimental**, and off by default.
+
+A Claude Cloud chat runs Claude Code in a sandbox at Anthropic instead of on the relay host. The sandbox works on its own clone of a GitHub repository: it sees what is pushed to GitHub and nothing on the host, and its results come back as branches the agent pushes. The chat is billed to the Claude account the relay host's Claude CLI is logged in to. In OAR it is a conversation like the others: the reply streams in, questions arrive as cards, and it works from the phone.
+
+**What it needs.**
+
+- The Claude CLI on the relay host, logged in with a claude.ai account (**⚙️ Settings → Providers → Claude → Relogin**, or `claude` on the host). The same login serves Claude chats.
+- GitHub connected to that Claude account: [claude.ai/connect-github](https://claude.ai/connect-github).
+- The Claude GitHub app allowed on every repository a cloud chat should work on (GitHub → Settings → Applications → Claude → Configure).
+
+**Enabling.** Turn on **⚙️ Settings → Providers → Claude Cloud → Enable Claude Cloud for New Chat**. It is off by default, and it is refused while the host has no Claude login. The tab then shows:
+
+- the account the chats are billed to, and where the relay reads the login from and until when it is valid. The login itself is changed on the Claude tab (**Claude login** jumps there);
+- **Cloud environment**: the environments of the account. With none saved, the relay takes the first active one and saves it. An account without any gets its default one when you open [claude.ai/code](https://claude.ai/code) once;
+- **Default model** for new cloud chats (`claude-sonnet-5-5` until you change it). The list is the Claude provider's models without their `[1m]` variants, plus the default.
+
+Switching Claude Cloud off takes it out of **New Chat**. Cloud conversations that already exist keep working.
+
+**Starting a chat.** Choose **+ New Chat → Provider → Claude Cloud**. The folder picker stays, but here it only fills in two fields, which you can also pick from a list or type yourself:
+
+- **Repository**: read from the folder's `origin` remote (or the remote of its upstream branch). With the field focused, OAR lists the repositories the Claude GitHub app can reach for the account (read from Anthropic, kept for a minute; **↻** next to the label reads it again), the ones used in earlier cloud chats on this relay first and marked "used here"; typing filters the list by `owner/name`, arrow keys and Enter pick, Escape closes. `owner/repo` or a GitHub URL, https or ssh, can still be typed or pasted; only GitHub repositories are accepted.
+- **Branch**: the folder's current branch; a repository picked from the list brings its default branch. With the field focused, OAR offers the repository's branches as the relay host's git sees them (`git ls-remote`, with the host's own GitHub login; the host's `OAR_CLAUDE_CLOUD_BRANCH_LOOKUP=off` turns this off). When the host cannot read them the field is a plain text field. Leave it empty for the repository's default branch.
+
+Under the fields OAR warns about what the cloud clone will not have: commits that are not pushed, a branch without an upstream, uncommitted changes. It also says when the folder is no git repository or has no GitHub remote, when the Claude GitHub app has no access to the repository in the field (the cloud would refuse the first message), and when no cloud environment is set. There is no reasoning effort to choose. The cloud session itself is created by the first message.
+
+**What works.**
+
+- The reply streams in as the agent writes it, with thoughts, tool activity, subagent bubbles and the steps of the sandbox starting up
+- Questions from the agent (`AskUserQuestion`) as question cards, multi-select included; a tool that asks for permission gets an **Allow** / **Deny** card. A card answered on claude.ai closes in OAR
+- **Stop** interrupts the cloud turn. If the cloud does not confirm within 30 seconds, the turn ends in OAR with a note that the agent may still be working there
+- Image attachments (JPEG, PNG, GIF or WebP, up to 5 MB each), sent inline
+- Follow-up messages go into the same cloud session, also after it has been idle for a long time
+- A restart of the worker or the relay in the middle of a turn does not send your message twice: the new worker finds the turn in the session's event log and follows it, and a turn that finished in the meantime is answered from the log. A dropped connection to the session is reopened where it broke off
+- The **cloud line** above the composer: the repository, the branch, a link to the session on claude.ai, one **⇡ branch** link per branch the agent pushed (it opens GitHub's comparison with the branch the chat started from) and what the session has cost so far. The `⋯` menu has **☁️ Open on claude.ai**
+- [Commit attribution](#claude-agent-sdk): commits and pull requests the agent makes in the sandbox end with what the Claude tab's setting says (**OAR**, **vanilla** or **off**), from the first message on, and a change reaches the sandbox with the next message. In OAR mode the `Claude-Session` link to claude.ai is left out too. A chat started from a folder follows that folder's override, and its **🧠** modal has the select. The commit's author is still the sandbox's git identity (`Claude`); the setting covers the lines at the end
+- A turn the session starts by itself — the agent's closing turn when its background work outlived the hold, or a message you sent on claude.ai — appears in the chat as a continuation reply, with a line saying where it came from; the worker keeps the session's event stream open for that
+- A turn the cloud refuses at the Claude usage limit is paused like a local Claude turn (a note with the reset time, the banner, and the work carries on by itself after the reset); the limit warning before it appears in the tool activity
+- Deleting or archiving the conversation archives the cloud session at Anthropic; nothing is deleted there
+- A **Claude Cloud** card in **Check Usage** with the account's cloud credit and the cost Anthropic reports for this relay's cloud sessions, and the **🧠** button for the session's context use (see [Usage and context](#usage-and-context))
+- A failure the relay can name says what to do: log in again, connect GitHub, give the Claude GitHub app access to the repository, choose an environment
+
+**What does not.**
+
+- No relay modes, no reasoning effort and no context size: the three selectors are hidden. The model is chosen in **New Chat** and can be changed between turns in the composer like a local Claude chat's (the sandbox switches before the next message)
+- No mid-turn steering: a message sent during a turn waits for the turn to end
+- Nothing from the relay host reaches the sandbox: attachments other than images are refused, there is no working directory to change and no **Session** folder to browse
+- No relay tools inside the sandbox: no `preview`, no `remote_relay`, no media embedded by host path
+- No background task panel
+
+**Started by an agent.** An agent in another session can start a cloud chat with the `remote_relay` tool, naming the repository and, if it wants one, the branch (`repo` and `branch`): an agent on a [paired relay](#remote-relays), under the rules for starting any session from there, or an agent on this relay once [agent sessions](#agent-sessions) are switched on. The same checks apply as in **New Chat** (the provider is on, an environment is set, the repository is on GitHub), and a chat without a requested model starts with the tab's default model. It can also read, prompt, wait for and stop a cloud chat you created.
+
+**What OAR does with the Claude login.** Claude Cloud uses the login the Claude CLI keeps on the relay host (`.credentials.json` in `~/.claude`, or in `CLAUDE_CONFIG_DIR`) to call the Anthropic API endpoints the Claude CLI itself uses for cloud sessions and account usage. **These endpoints are not a documented public API.** Anthropic can change them without notice; cloud chats and the live usage figures then fail with a note until OAR is updated. If you are not comfortable with a program other than the CLI using its login this way, leave the provider off.
+
+- The relay and its cloud workers only **read** the access token. It is sent as the bearer token to `https://api.anthropic.com` and to no other host. (OAR's own tests point the client at a fake API on the same machine; that setting accepts a loopback address and nothing else.)
+- It is held in memory only. It is never written to the database or to a log, never sent to the browser and never put into an error message. Each cloud worker reads the credentials file itself, so nothing is passed along at launch.
+- It is never refreshed by OAR, and the refresh token is never used. The CLI keeps its own login fresh; when the token has run out, the relay — and a cloud chat's worker, through the relay — reads the file again and at most once in five minutes has the CLI check its own login (`claude auth status`, which refreshes a login whose refresh token is still good), then retries. A login that is still expired ends the turn with a note to log in again.
+- While the switch is off, the relay asks Anthropic for nothing with this login: it lists no environments and reads no account usage. Only a cloud conversation from before still talks to its session, when you write to it, delete it or archive it.
+- The provider is off by default. Switching it on is the consent for all of the above.
+
+`CLAUDE_CODE_OAUTH_TOKEN` in the relay's environment is used instead of the credentials file when it is set. That is the one case in which the relay passes the login on: a cloud worker started under tmux gets the variable through a file only the relay's user can read, which the worker's shell reads once and deletes; workers of other providers are not given it that way (see [Environment variables](#environment-variables)).
+
 ### Cursor (Agent SDK)
 
 Turn on **⚙️ Settings → Providers → Cursor**, paste your Cursor API key, and enable it for New Chat model selection. Saving the key runs model discovery and also discovers each model's supported reasoning-effort tiers; use **🤗 Select Models → Cursor SDK** to choose which models appear in the composer (the configured default model, `composer-2.5` unless you change it, always stays enabled).
@@ -319,13 +387,23 @@ The composer's model picker is the union of every enabled provider's catalog, fi
 - **Copilot** models are discovered from the installed Copilot CLI runtime a few seconds after the relay starts, and refreshed by the sessions that run on it. Each model shows the reasoning efforts and context window the runtime reports. The list starts with `auto`, then groups models by vendor (OpenAI, Anthropic, Google, xAI, Microsoft, Azure OpenAI, Moonshot AI, then any others alphabetically), newest version first. Before the first discovery, a fresh relay offers a curated set: `gpt-5.4`, `gpt-5.4-mini` (the default), `gpt-5.3-codex`, `claude-sonnet-4.6`, and `claude-haiku-4.5`.
 - **OpenAI (BYOK)** models are discovered from `/v1/models` when the key is saved or re-enabled.
 - **Claude** models are discovered from the Agent SDK when the provider is enabled. Bracketed `[1m]` long-context variants (such as `claude-opus-5[1m]`) do not appear as separate entries; they surface as a 1M option in the composer's context-size dropdown for the base model.
+- **Claude Cloud** has no discovery of its own: its picker offers the Claude provider's models under their plain ids, plus the tab's default model.
 - **Cursor** models (and their per-model reasoning-effort tiers) are discovered when the API key is saved or the provider is re-enabled.
 - **Grok** models are discovered from the Grok CLI over ACP when the provider is enabled, after a sign-in, and after a CLI install from the panel.
 
-Use **🤗 Select Models** to choose which variants show up in the composer, then **💾 Save enabled models**; **Refresh** reruns discovery for every enabled runtime. The modal has one tab per runtime — **Copilot**, **OpenAI**, **Claude SDK**, **Cursor SDK**, **Grok** — and each tab lists only the models that runtime serves; there is no cross-runtime switching inside a conversation.
+Use **🤗 Select Models** to choose which variants show up in the composer, then **💾 Save enabled models**; **Refresh** reruns discovery for every enabled runtime. The modal has one tab per runtime — **Copilot**, **OpenAI**, **Claude SDK**, **Cursor SDK**, **Grok** — and each tab lists only the models that runtime serves; there is no cross-runtime switching inside a conversation. Claude Cloud has no tab there.
 
 ## Highlights
 
+### New in 0.9.7
+
+- **Claude Cloud (experimental, off by default)**: a chat that runs Claude Code in a sandbox at Anthropic, on its own clone of a GitHub repository. Pick the repository and branch from a list, follow the turn live, answer its questions, stop it, change the model between turns; the results come back as pushed branches. See [Claude Cloud](#claude-cloud) for what it needs and what it does with the Claude login.
+- **Archive, and a menu on every conversation**: archive a conversation instead of deleting it (🗄 shows the archived ones), and right-click a row, or long-press it on a phone, to open, rename, stop, kill, archive or delete it.
+- **Agent sessions**: an agent can start other sessions on the relay it runs on, wait for them and read their results, once you switch it on under Settings → Relays.
+- **Commits say Open Agent Relay**: commits and pull requests of Claude sessions carry `Co-authored-by: Open Agent Relay (<model>)`; choose OAR, Claude Code's own lines or none, per relay and per folder.
+- **Check Usage opens at once**: the last reading shows immediately and only the open tab is read live.
+- **Fixes**: two prices in one paragraph are no longer shown as a formula, a reply that names an error code is no longer stored as a failed turn, and on Windows the relay no longer stalls or fails to start workers while it reads the process list.
+
 ### New in 0.9.6
 
 - **Claude pauses at the usage limit**: a turn that runs into the subscription's usage limit is paused instead of failed. A banner above the composer says when it carries on, with **Resume now** and **Cancel**; after the reset the relay sends a message of its own that quotes what was refused. The pause survives a relay restart, and a reset more than six hours away waits for you. A second banner warns when the usage passes 90 % of a limit.
@@ -360,10 +438,10 @@ Use **🤗 Select Models** to choose which variants show up in the composer, the
 - Nested **subagent bubbles**: each subagent gets its own live bubble with its own thoughts, activity, and streamed text, kept as collapsible sections after the turn finishes
 - **Background task panel** with live per-task state, model, and token use; Claude workflow tasks fold out into a progress tree of phases and agents, and leave a *Finished background task* card in the transcript when they complete
 - Question cards for clarification: one-click choices, multi-select checkmarks, free text, and multi-field structured forms validated against their JSON schema
-- Mathematical and scientific notation rendering for TeX/LaTeX equations and chemical formulas
+- Mathematical and scientific notation rendering for TeX/LaTeX equations and chemical formulas, written as `$…$`, `\(…\)`, `$$…$$` or `\[…\]`. A single `$` opens a formula only when a non-space character follows it directly and the next `$` has a non-space character directly before it and no digit directly after it (a digit is allowed after something that looks like TeX, as in `$x^2$3`), so prices such as `$5 and $9` stay text
 - **Context usage** modal with a per-category token breakdown of the model's context window, plus a per-conversation **auto-compact window** slider for Claude sessions
 - **Transcript breaks**: day separators, a marker where a Claude session auto-compacted its context, and matching dots beside the scrollbar
-- **Plan usage** modal with subscription credits, rate-limit windows, and reset countdowns for Copilot, Claude, Cursor, and Grok
+- **Plan usage** modal with subscription credits, rate-limit windows, and reset countdowns for Copilot, Claude, Claude Cloud, Cursor, and Grok
 - **Image conversations** (OpenAI Image): generate images in chat and iterate on a generated image with **Edit this image**
 - Agents can embed **images, video, and audio** in a reply by their absolute path, on every runtime; clicking an embedded image opens the file viewer with zoom, download, and copy
 - **Screenshot annotations**: mark up an uploaded screenshot with highlighter strokes before or after sending; the original upload is never modified
@@ -380,7 +458,7 @@ Use **🤗 Select Models** to choose which variants show up in the composer, the
 
 ### Starting a conversation
 
-- Start a chat with **+ New Chat**, which asks for the **Working directory**, **Provider**, **Model**, and **Reasoning effort** (or **Quality** and **Size**, for image chats; **Context window** where a model offers several) before the conversation exists. The working-directory list offers the known directories (current session, relay workspace, browser folder, recent roots), a **Custom path…** entry, and a 📁 folder picker; it defaults to the directory you picked last, and the chosen directory is applied before the session worker first launches. With Copilot as the only provider the provider row is hidden.
+- Start a chat with **+ New Chat**, which asks for the **Working directory**, **Provider**, **Model**, and **Reasoning effort** (or **Quality** and **Size**, for image chats; **Context window** where a model offers several) before the conversation exists. The working-directory list offers the known directories (current session, relay workspace, browser folder, recent roots), a **Custom path…** entry, and a 📁 folder picker; it defaults to the directory you picked last, and the chosen directory is applied before the session worker first launches. With Copilot as the only provider the provider row is hidden. For **Claude Cloud** the modal asks for a **Repository** and a **Branch** instead of a reasoning effort, filled in from the chosen folder (see [Claude Cloud](#claude-cloud)).
 - Choose the **mode** and **model** per message in the composer.
 - The composer knows two slash commands, with autocomplete: **`/compact`** branches to a fresh conversation seeded with summary context, and **`/preview`** publishes a local dev server or directory on the public preview host without involving the agent (`/preview 5173 [label]`, `/preview ./dist [label]`, `/preview list`, `/preview close`). Agents can do the same through the `preview` tool (Claude and Cursor) or the documented API (see [docs/preview-servers.md](docs/preview-servers.md)). Any other single-line text starting with `/` is held back once with an *Unknown command* notice; press send again to send it as text.
 
@@ -402,7 +480,7 @@ Use **🤗 Select Models** to choose which variants show up in the composer, the
 
 ### Question cards
 
-- Agents ask clarifying questions through question cards: `ask_user` on Copilot and Cursor, `AskUserQuestion` on Claude. A choice answers with one click; a question that allows several answers shows checkmarks and one **Reply with selection** button, whose reply lists every ticked choice plus anything you typed. Structured requests render as multi-field forms.
+- Agents ask clarifying questions through question cards: `ask_user` on Copilot and Cursor, `AskUserQuestion` on Claude and Claude Cloud. A choice answers with one click; a question that allows several answers shows checkmarks and one **Reply with selection** button, whose reply lists every ticked choice plus anything you typed. Structured requests render as multi-field forms.
 - On Copilot's SDK engine, the model gets OAR's own `ask_user` tool, which can mark a question as multi-select; a question worded "select all that apply" counts too, and every Copilot choice card that accepts free text has a **Select several** switch.
 - A card waits 8 hours for an answer (2 hours on Copilot's Extension engine). After that the agent is told nobody answered and continues according to the conversation's mode. A turn that is waiting on a card is never treated as stuck.
 - Grok has no question cards: ACP has no ask-user surface.
@@ -423,13 +501,15 @@ The composer draft, attachments included, is saved per conversation on the relay
 - **Filter conversations…** above the list matches titles, ignoring case. It clears with **×** or Escape, and while it is active it loads older pages, so it searches every conversation, not just the loaded ones.
 - **🔍** in the conversation header searches message text across all conversations.
 - On startup, the relay imports the Copilot sessions stored on the host (through the installed Copilot runtime) into its database, so they appear in the list with their history. If the runtime is unavailable, the import is reported as failed rather than guessed from the filesystem.
-- Deleting a conversation stops its session worker and removes its CLI session too (Copilot through the runtime, Claude by deleting that session's transcript). An imported Copilot session the relay never ran is only hidden: its CLI session stays, and nothing is stopped for it. A conversation that is still working — a running turn, one waiting on a question card or approval, or live background tasks — is not deleted, and the sidebar says why so you can stop it first.
+- **Archive** (🗄 on the row, or **Archive conversation** in the `⋯` menu) takes a conversation out of the list without deleting anything: its session worker is stopped, and a Claude Cloud chat's session at Anthropic is archived with it. The 🗄 toggle above the list shows the archived conversations; **Unarchive** (📂) brings one back, cloud session included. An archived chat that is opened cannot be sent to until it is unarchived; a message that reaches it anyway (an agent's through a paired relay, say) unarchives it. A conversation that is still working is not archived — stop it first.
+- A **right-click on a row** (a long press on a phone) opens a menu with Open, Edit title, Stop turn, Kill session, Archive or Unarchive, and Delete, so a session can be stopped or killed without opening it.
+- Deleting a conversation stops its session worker and removes its CLI session too (Copilot through the runtime, Claude by deleting that session's transcript). A Claude Cloud conversation's session at Anthropic is archived, not deleted. An imported Copilot session the relay never ran is only hidden: its CLI session stays, and nothing is stopped for it. A conversation that is still working — a running turn, one waiting on a question card or approval, or live background tasks — is not deleted, and the sidebar says why so you can stop it first.
 
 ### Files, git, and previews
 
 - Use **📁 Browse files** to inspect the workspace (💼), drives (📀), or the session's own folder (🕵️), and to open previews. The **Hidden** and **Heavy** toolbar filters are remembered per browser, and a refresh re-opens the folders you had expanded.
 - Click the file and folder copy controls to insert `@file:...` / `@folder:...` tokens.
-- Workspace browsing follows the selected session's effective working directory. Running sessions keep their learned runtime directory, **🗂️ Change CWD** in the `⋯` menu changes the directory for the next launch, and `cd ...` typed in chat does not retarget the browser.
+- Workspace browsing follows the selected session's effective working directory. Running sessions keep their learned runtime directory, **🗂️ Change CWD** in the `⋯` menu changes the directory for the next launch, and `cd ...` typed in chat does not retarget the browser. A Claude Cloud chat has no **Change CWD**: it works on a clone at Anthropic.
 - Use **🌿 Git changes** in the conversation `⋯` menu to review the workspace repository: the header shows the branch with ahead/behind counts and a **⬇ Pull** button, and the list shows every staged, unstaged, and untracked file (deleted files struck through). Clicking a file opens a diff viewer with **Changes** and **Full file** modes; closing it returns to the still-open list.
 - Agents can embed images, video, and audio in a reply by absolute path; they render inline.
 - Tap an image attachment in the composer (it carries a 🖍️ badge), or use **🖍️ Annotate** in the file viewer, to mark it up with highlighter strokes. The annotated copy is uploaded; the original stays untouched.
@@ -437,13 +517,14 @@ The composer draft, attachments included, is saved per conversation on the relay
 
 ### Usage and context
 
-- Use **📊 Check Usage** in the conversation `⋯` menu for plan usage across every configured provider: remaining credits, rate-limit windows, reset countdowns, and collapsible cost/token detail. Each provider gets its own tab, opening on the conversation's own provider, and the card names the signed-in account (email and plan) beneath its title. Sources differ per provider:
+- Use **📊 Check Usage** in the conversation `⋯` menu for plan usage across every configured provider: remaining credits, rate-limit windows, reset countdowns, and collapsible cost/token detail. Each provider gets its own tab, opening on the conversation's own provider, and the card names the signed-in account (email and plan) beneath its title. The modal opens on the reading it showed last time and reads only the open tab's provider live (its card says "updating…" until the answer is in); a tab you switch to is read live when its reading is older than a minute, **Refresh** reads the open tab, and the relay keeps the last live answer of every provider so the other cards are never empty. Sources differ per provider:
   - **Copilot** — live quota (AI credits or premium requests, chat, plan), plus per-model/product billed cost when your GitHub token can read personal billing. Conversations on the SDK engine add a **Last SDK worker turn** section (AI credits actually spent, tokens, model calls, overage) with the model and how long ago it was captured; it is one turn's numbers rather than a running total, and it stops being shown once it is more than seven days old.
-  - **Claude** — subscription limit windows (5-hour, weekly, per-model), extra-usage credits, session cost, and local usage attribution. Read from the live session at the end of a turn; the relay never starts a hidden turn to refresh it, so the newest reading is from your last Claude turn.
+  - **Claude** — subscription limit windows (5-hour, weekly, per-model), extra-usage credits, session cost, and local usage attribution. Read from the live session at the end of a turn; the relay never starts a hidden turn to refresh it, so the newest reading is from your last Claude turn. With **Claude Cloud** switched on, the limits are read live from the account each time the modal opens (kept for a minute), with no turn involved: the card then carries a **Live** badge, a limit that is getting close carries Anthropic's own warning word, and it adds **This week by product** (Claude Code, chats and the other products as shares of the week) and the organisation's **Prepaid credits** when there are any. Limit resets (full and 5-hour) are shown on claude.ai only; the card links there. When the live read fails, the card falls back to the last turn's reading and says why.
+  - **Claude Cloud** — shown while the provider is on. A meter per dollar credit the account holds, with what is used, what is left and when it expires; **Cloud spend (OAR sessions)**, the cost Anthropic reports per cloud session, summed over the cloud conversations this relay still has, with this conversation's own cost when the modal was opened from a cloud chat; and the latest cloud session report (its cost, and cost and tokens by model). These figures are Anthropic's reported cost, not a billing statement, and sessions started elsewhere are not counted. A credit that is offered but not yet claimed is mentioned with a link to claude.ai. Cloud turns spend the cloud credit first; without a credit they count against the Claude limits above.
   - **Cursor** — spend from the Cursor SDK measured against the monthly allowances you enter in Settings, split into the Cursor Models and Other Models pools; these figures are estimates, and Cursor's Spending dashboard remains authoritative. With a dashboard session token, the card adds live *Included in plan* bars.
   - **Grok** — the live weekly subscription quota, read with the host's Grok CLI login, plus per-turn tokens and estimated cost from the agent's prompt result. An optional monthly USD allowance in Settings adds an estimated remaining meter; the card is hidden when Grok is disabled. Billing: [console.x.ai](https://console.x.ai).
-- Per-reply usage lines are recorded only for Copilot turns — OpenAI, Claude, Cursor, and Grok turns do not consume Copilot premium requests, and no usage line is attached to them.
-- Use the **🧠** context button for a per-category breakdown of the conversation's context window: a usage bar, a token/percentage table, and free space. Claude sessions report exact SDK categories; Copilot sessions show the coarser system/tools + messages + buffer split, labelled as a lower-bound estimate when the runtime no longer emits full buckets.
+- Per-reply usage lines are recorded only for Copilot turns — OpenAI, Claude, Claude Cloud, Cursor, and Grok turns do not consume Copilot premium requests, and no usage line is attached to them.
+- Use the **🧠** context button for a per-category breakdown of the conversation's context window (Claude sessions also show the auto-compact window, the thinking controls and the folder's commit attribution there): a usage bar, a token/percentage table, and free space. Claude sessions report exact SDK categories; Copilot sessions show the coarser system/tools + messages + buffer split, labelled as a lower-bound estimate when the runtime no longer emits full buckets. A Claude Cloud session reports how much of its window is used after each turn, without categories.
 - Claude conversations additionally get an **auto-compact window** slider in that modal. Claude Code compacts a session once it approaches a model-tuned window (around 967k tokens on a 1M-context model), which is why long conversations rarely compact at all; setting a smaller window makes it happen sooner and keeps turns cheaper. *Auto* hands the choice back to the CLI. The smallest window is 100k, because the CLI silently ignores anything below that and falls back to its own default. The line beneath the slider reports the window actually in force and where it came from — your setting, the model default, or the `CLAUDE_CODE_AUTO_COMPACT_WINDOW` environment override — and fills in once the conversation's first turn completes. The change reaches a running session on its next message.
 - The transcript marks day boundaries, and marks the point where a Claude session compacted its context with the tokens before and after. Both appear as dots beside the scrollbar for the messages currently loaded.
 
@@ -458,7 +539,7 @@ Use **➡️ Share conversation** in the `⋯` menu to publish a read-only link.
 
 ### The conversation menu
 
-Besides the entries above, the `⋯` menu holds **✍️ Edit conversation title**, **🖥️ Inspect tmux console** (a read-only view of the session's tmux pane), **🤗 Select Models**, **⚙️ Settings**, **🌄 Restart web relay** (queued until the current turn is idle), **💤 Suspend host** (Windows; see below), and **☠️ Kill session** (stops the conversation's worker; an active turn then needs a retry or a new message). Its header shows the queue counts with **🚮 Empty queue**.
+Besides the entries above, the `⋯` menu holds **✍️ Edit conversation title**, **🗄 Archive conversation** (**📂 Unarchive** on an archived chat), **🖥️ Inspect tmux console** (a read-only view of the session's tmux pane), **🤗 Select Models**, **☁️ Open on claude.ai** (Claude Cloud chats, once their session exists), **⚙️ Settings**, **🌄 Restart web relay** (queued until the current turn is idle), **💤 Suspend host** (Windows; see below), and **☠️ Kill session** (stops the conversation's worker; an active turn then needs a retry or a new message). Its header shows the queue counts with **🚮 Empty queue**.
 
 **💤 Suspend host** puts the machine the relay runs on to sleep, once the work is done. The confirmation lists what is still active. The relay then queues the suspend and fires it after 2 minutes with nothing active: no queued, running or parked turn, no background task of a live worker, and no open GitHub Actions run in the repository of a conversation that was busy since the request (read through `gh`; a repository whose state cannot be read blocks for 15 minutes, then is ignored). With nothing running when you confirm, it fires after a 30-second countdown. While a suspend is queued, every device shows a banner with the blockers or the countdown and a **Cancel** button, and a push notification reports the suspend. A relay restart drops a queued suspend and says so. **Show Suspend host action** in Settings hides the entry per browser.
 
@@ -466,7 +547,7 @@ Besides the entries above, the `⋯` menu holds **✍️ Edit conversation title
 
 ### Settings (⚙️ in the web UI)
 
-The modal is organised into six tabs — **General**, **Providers** (with a **Copilot**, **OpenAI**, **Claude**, **Grok**, and **Cursor** sub-tab), **Relays**, **Previews**, **Notifications**, and **Features** — and reopens on the tab you used last. Unless noted as per browser, these settings live in the relay database rather than the config file, and apply to every browser that connects:
+The modal is organised into six tabs — **General**, **Providers** (with a **Copilot**, **OpenAI**, **Claude**, **Claude Cloud**, **Grok**, and **Cursor** sub-tab), **Relays**, **Previews**, **Notifications**, and **Features** — and reopens on the tab you used last. Unless noted as per browser, these settings live in the relay database rather than the config file, and apply to every browser that connects:
 
 | Tab | Setting | Default | What it does |
 | --- | ------- | ------- | ------------ |
@@ -482,9 +563,13 @@ The modal is organised into six tabs — **General**, **Providers** (with a **Co
 | Providers | OpenAI API key / model / base URL | — / `gpt-4o` / `https://api.openai.com/v1` | Enables the OpenAI and OpenAI Image providers |
 | Providers | Claude (Agent SDK) | off | Enables Claude as a New Chat provider and runs model discovery; default model `claude-sonnet-5` |
 | Providers | Claude account (Relogin / Logout) | host login | Switches the Claude account the relay host's CLI uses, from the browser (see [Claude (Agent SDK)](#claude-agent-sdk)) |
+| Providers | Claude Cloud | off | Enables Claude Cloud as a New Chat provider, and the live account figures in **Check Usage**; the switch is the consent to use the Claude CLI's login (see [Claude Cloud](#claude-cloud)) |
+| Providers | Claude Cloud environment / default model | first active environment of the account / `claude-sonnet-5-5` | The cloud environment new cloud sessions run in, and the model a new cloud chat starts with |
 | Providers | Cursor API key / model | — / `composer-2.5` | Enables Cursor; plus monthly plan allowances and the optional dashboard session token |
 | Providers | Grok | off | Enables Grok; default model `grok-4.5`; **Sign in** / **Sign out**; optional monthly allowance |
 | Relays | Public address, Accept prompts from other relays' agents | browser address / on | How paired relays reach this one, and whether their agents may prompt sessions here (see [Remote relays](#remote-relays)) |
+| Relays | Agent sessions: Agents may start and use sessions on this relay | off | Lets agents on this relay start and use other sessions here with the `remote_relay` tool; the first session an agent starts in a conversation asks for your approval (see [Agent sessions](#agent-sessions)) |
+| Relays | Agent sessions: Longest wait per tool call | `10 min` | How long one `remote_relay` call may wait for a reply (2 to 60 minutes), on this relay and on paired ones; adjustable whether or not the switch above is on |
 | Relays | Remote relays | — | Pair a relay by pasting its web address; per relay **Agents may** read only, read and prompt, or do everything |
 | Previews | Live previews | — | Lists the published previews, each of which you can close |
 | Notifications | Push notifications | off | Per device: which events notify, and whether titles and message previews are included |
@@ -564,7 +649,8 @@ The config file is `server/config.json` in a git checkout and `~/.oar/config.jso
 | `GH_TOKEN`, `GITHUB_TOKEN` | GitHub token for the Copilot usage card, instead of `gh auth token` |
 | `XAI_API_KEY` | Grok authentication instead of the Grok CLI login |
 | `CURSOR_SESSION_TOKEN` | Cursor dashboard session token for live plan bars |
-| `CLAUDE_CONFIG_DIR` | Claude configuration directory, instead of `~/.claude` |
+| `CLAUDE_CONFIG_DIR` | Claude configuration directory, instead of `~/.claude`; Claude Cloud reads the CLI's login (`.credentials.json`) from it |
+| `CLAUDE_CODE_OAUTH_TOKEN` | A Claude login token for Claude Cloud, used instead of the CLI's credentials file, by the relay (settings tab, **Check Usage**, archiving) and by its cloud workers. Under tmux the relay hands it to cloud workers only, through an owner-only file; a worker started without tmux inherits the relay's environment as it is |
 | `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Overrides the Claude auto-compact window |
 | `COPILOT_CLOUDFLARED_MODE`, `COPILOT_CLOUDFLARED_TOKEN`, `COPILOT_CLOUDFLARED_BINARY` | Override `cloudflaredTunnel.mode`, `.token`, and `.binary` |
 | `COPILOT_WORKSPACE_ROOT_ALLOW_LIST` | Same as `workspaceRootAllowList` |
@@ -697,12 +783,22 @@ conversation has sent 30 prompts to agents on other relays without a message fro
 one asks you first with a question card; **Allow** starts the count again.
 
 **What agents can do.** Every provider gets the same `remote_relay` tool (Claude, Cursor and
-Copilot directly; Grok and the Copilot extension engine through OAR's MCP server). Per paired
+Copilot directly; Grok and the Copilot extension engine through OAR's MCP server). Sessions get it
+while at least one relay is paired or [agent sessions](#agent-sessions) are switched on. Per paired
 relay, **Agents may** limits it to *read only*, *read and prompt* (existing sessions) or *full*
 (also create sessions, answer questions, stop turns, archive). In the *ask* and *plan* relay
 modes, every write action first asks you with a question card. For a session it starts, an agent
 can set the provider, model, relay mode and reasoning effort; what it leaves out follows the
-session it works in, as far as the other relay offers it.
+session it works in, as far as the other relay offers it. A [Claude Cloud](#claude-cloud) session
+is started with `provider: "claude-cloud"`, a `repo` (a GitHub URL or `owner/repo`, for example
+`example-org/sample-repo`) and an optional `branch` instead of a folder; without a model it gets
+the default model of the other relay's Claude Cloud tab. Claude Cloud must be switched on there.
+A cloud session that exists can be read, prompted, waited for and stopped like any other.
+
+A `send`, `create_session` or `wait` call waits for the reply for as long as the agent asks, up to
+**Longest wait per tool call** of the relay the agent runs on (10 minutes unless you changed it,
+see [Agent sessions](#agent-sessions)). When the time is up the agent gets what there is so far
+and can call `wait` again.
 
 When an agent prompts a session on another relay, that relay shows a **↗ from …** badge with the
 sending relay, session and model on the message, and marks sessions an agent created in the
@@ -715,6 +811,58 @@ The calls go through your own relay, which holds the other relay's token: agents
 token. Remote addresses must use `https://`; plain `http://` is accepted only for loopback (an
 SSH port forward, for example) and private network ranges.
 
+### Agent sessions
+
+The same `remote_relay` tool can also work on the relay the agent itself runs on. An agent can
+then hand parts of its task to other sessions: it starts them, waits for them and reads their
+replies. Every session it starts is an ordinary conversation in your list. No relay has to be
+paired for this.
+
+**Switching it on.** It is off by default. Turn on **Settings → Relays → Agent sessions →
+Agents may start and use sessions on this relay**. From then on this relay is the first entry of
+the relay list an agent sees, marked as its own; the agent names it by its **Relay name** or as
+`this`. It needs no mention, and **Agents may** and **Accept prompts from other relays' agents**
+do not apply to it. On this relay an agent can do what *full* allows on a paired one: list and
+read every session here, prompt one, start one, wait for it, answer its question, stop its turn
+and archive it. Switching the setting off closes this relay to the tool again.
+
+**The rules.**
+
+- **Approval once per conversation.** The first time the agent of a conversation wants to start
+  a session here, a question card (**Agent sessions**) shows the provider, the folder or
+  repository and the prompt. **Allow** covers every session that conversation's agent starts
+  later, also after a relay restart; **Deny** refuses that one call. In the *ask* and *plan*
+  relay modes, every other write action still asks, as it does for a paired relay.
+- **At most 4 at work.** Of the sessions one conversation's agent started, 4 may have a turn
+  queued or running at the same time. A fifth is refused until one of them has finished.
+- **One level only.** A session that an agent created, here or from a paired relay, cannot start
+  sessions on this relay.
+- **Not on itself.** An agent cannot prompt, stop, archive, wait for or answer the conversation
+  it runs in.
+- The count of 30 prompts without a message from you (see above) includes prompts to sessions
+  on this relay.
+
+**What it can start.** A session with any provider that is enabled on this relay (Copilot,
+OpenAI, Claude, Cursor, Grok or Claude Cloud; not an OpenAI Image chat): in a folder
+(the relay's default folder when the agent names none), or a [Claude Cloud](#claude-cloud) chat
+with `provider: "claude-cloud"`, `repo` and an optional `branch`. A new session knows nothing of
+the conversation it was started from. Sessions an agent starts use this relay's accounts and
+count against their usage.
+
+**In the conversation list.** A session an agent on this relay started carries **via agent ·
+“title”** in the sidebar and under the title in the header, with the title of the conversation
+the agent runs in; clicking it opens that conversation while it is still in the list. The
+agent's prompts carry the same marker, with its model, as a badge on the message. The relay never
+archives these sessions by itself: they stay in the list until you archive or delete them, or the
+agent archives one with the tool.
+
+**Longest wait per tool call.** The slider under the switch sets how long one `send`,
+`create_session` or `wait` call may wait for a reply: 10 minutes by default, from 2 to 60 minutes
+in steps of one minute. The agent can call `wait` again to keep waiting. The limit also applies
+to this relay's agents when they wait for a session on a paired relay, so the slider can be moved
+whether or not the switch above it is on. A turn that waits is still subject to **Max turn duration**
+under **General** (60 minutes by default), which does not know about the wait.
+
 ## Security notes
 
 - The auth token guards the API and the Socket.IO channel. A browser signs in once, with the token or with a URL carrying `?token=` (such as the one `oar setup` prints and puts in its QR code), and then holds an HttpOnly cookie for 30 days, marked `Secure` when the relay is reached over HTTPS. Treat the token, and that URL, like a password.
@@ -724,6 +872,7 @@ SSH port forward, for example) and private network ranges.
 - Shared conversation links and preview links are public by design: anyone with the URL can read the shared transcript or reach the previewed app, without signing in.
 - A [paired relay](#remote-relays) holds a token that opens the other relay completely. The per-relay "Agents may" limit and the "Accept prompts from other relays' agents" switch are honoured by OAR's own traffic, but anyone holding the token can still use the full API: the token is the real boundary. A token entered for a paired relay is stored like the API keys below and never sent to browsers or agents.
 - API keys you enter (OpenAI, Cursor) are stored in the relay database on the host and never sent to browsers. Claude and Grok credentials stay with their CLIs on the host.
+- Claude Cloud, when you switch it on, reads the Claude CLI's login and uses it against Anthropic API endpoints that are not a documented public API. The token is only read and held in memory, and goes to `api.anthropic.com` only (see [Claude Cloud](#claude-cloud)). A cloud agent works in Anthropic's sandbox, not on your host.
 - OAR has no telemetry. Its only request to oar.sh is the update check, which is off until you enable it.
 
 ## Troubleshooting
@@ -739,6 +888,9 @@ SSH port forward, for example) and private network ranges.
 | File links fail                    | Verify auth token/cookie and that paths are inside allowed workspace/drive roots |
 | Claude missing from New Chat       | Enable it in **⚙️ Settings → Providers → Claude**; the toggle is off by default   |
 | Claude reply says it cannot authenticate | Press **Claude settings** on the failed reply, then **Relogin** (or run `claude` on the relay host), and retry the turn |
+| Claude Cloud missing from New Chat | Enable it in **⚙️ Settings → Providers → Claude Cloud**; it is off by default and needs a Claude login on the relay host |
+| Claude Cloud reply says GitHub is not connected, or the Claude GitHub app has no access | Connect GitHub to the Claude account at [claude.ai/connect-github](https://claude.ai/connect-github), or add the repository to the Claude GitHub app's repository access on GitHub; then send the message again |
+| New Chat says *No cloud environment is set* | Choose one in **⚙️ Settings → Providers → Claude Cloud**; an account without any gets its default one when you open claude.ai/code once |
 | Grok reply says the CLI was not found | Press **Install Grok CLI** on the failed reply, or install it from **⚙️ Settings → Providers → Grok**; no relay restart is needed afterwards |
 | Grok reply says authentication failed | Press **Sign in to Grok** on the failed reply and confirm the device code in a browser |
 | Long turn requeued unexpectedly    | Raise or clear **Max turn duration** in Settings (0 = no limit)                  |
@@ -747,7 +899,7 @@ SSH port forward, for example) and private network ranges.
 | A conversation seems wedged        | **☠️ Kill session** in the `⋯` menu stops its worker; retry the turn or send a new message |
 | **🌄 Restart web relay** fails with *localhost-only* | The restart endpoint accepts loopback connections only: use it on the relay host or through a tunnel, not over a direct LAN connection |
 | `npm install -g @oar-sh/oar` fails with node-gyp or prebuild errors | `better-sqlite3` has no prebuilt binary for your platform; install a C/C++ build toolchain and Python, then retry |
-| No usage line under a reply        | Expected for OpenAI, Claude, Cursor, and Grok turns; only Copilot turns record plan usage |
+| No usage line under a reply        | Expected for OpenAI, Claude, Claude Cloud, Cursor, and Grok turns; only Copilot turns record plan usage |
 
 ## Repository layout
 
@@ -757,6 +909,7 @@ oar/
 ├── bin/                            # The `oar` command (oar.js) and a Windows cmd shim for checkouts (bat/oar.bat)
 ├── docs/                           # Preview-server guide, Copilot BYOK notes, SDK feature tracker
 ├── server/
+│   ├── claude-cloud-worker/        # Claude Cloud session worker (follows a cloud session's event stream; runs no agent itself)
 │   ├── claude-worker/              # Claude Agent SDK session worker (turn runner, ask-user bridge, attachments)
 │   ├── copilot-worker/             # Copilot SDK engine session worker (steering, background tasks, questions)
 │   ├── cursor-worker/              # Cursor Agent SDK session worker (turn runner, mode nudges, auth retry)
@@ -770,6 +923,7 @@ oar/
 │   ├── server.js                   # Entry point: supervisor plus relay runtime
 │   └── server-runtime.mjs          # Express + Socket.IO relay server
 ├── shared/                         # Code shared by the server, the extension, and the workers
+│   ├── claude-cloud/               # Claude Cloud API client, credentials reader, repository and branch rules
 │   └── worker-runtime/             # Common worker plumbing (relay API client, heartbeat, worker link)
 ├── tests/                          # Playwright end-to-end suite and its isolated relay harness
 ├── CHANGELOG.md