@oar-sh/oar 0.9.4 → 0.9.6

package/.github/extensions/web-relay/polling/polling-loop.mjs

@@ -6,7 +6,7 @@ import {
 } from "../runtime/send-and-wait-errors.mjs";
 import { getActiveSession } from "../runtime/session-registry.mjs";
 import { DEFAULT_QUESTION_TIMEOUT_MS } from "../../../../shared/question-timeout.mjs";
-import { QUESTION_TIMEOUT_CONTINUATION_TEXT } from "../../../../shared/question-timeout.mjs";
+import { waitForRelayQuestion } from "../../../../shared/question-wait.mjs";
 import { EMPTY_TURN_COMPLETION_NOTE } from "../../../../shared/empty-turn-completion.mjs";
 import { stripPromptContextPrefix } from "../skills/prompt-context.mjs";
 
@@ -473,37 +473,17 @@ export function createPollingLoop({
     return null;
   };
 
-  async function waitForRelayQuestionAnswer(questionId, timeoutMs = DEFAULT_QUESTION_TIMEOUT_MS, pollIntervalMs = 1500) {
-    const started = Date.now();
-    while (true) {
-      const { question } = await api("GET", `/api/relay-question/${questionId}`);
-      if (!question) throw new Error("Relay question missing");
-      if (question.status === "answered") {
-        return {
-          answer: String(question.answer || "").trim(),
-          structuredAnswer: question.structuredAnswer && typeof question.structuredAnswer === "object"
-            ? question.structuredAnswer
-            : null,
-          timedOut: false,
-        };
-      }
-      if (question.status === "timed_out" || question.status === "cancelled") {
-        return {
-          answer: QUESTION_TIMEOUT_CONTINUATION_TEXT,
-          structuredAnswer: null,
-          timedOut: true,
-        };
-      }
-      if (Date.now() - started >= timeoutMs) {
-        await api("POST", `/api/relay-question/${questionId}/timeout`, {}).catch(() => {});
-        return {
-          answer: QUESTION_TIMEOUT_CONTINUATION_TEXT,
-          structuredAnswer: null,
-          timedOut: true,
-        };
-      }
-      await sleep(pollIntervalMs);
-    }
+  // The wait survives a relay that is briefly not there
+  // (shared/question-wait.mjs).
+  function waitForRelayQuestionAnswer(questionId, timeoutMs = DEFAULT_QUESTION_TIMEOUT_MS, pollIntervalMs = 1500) {
+    return waitForRelayQuestion({
+      api,
+      questionId,
+      deadlineMs: timeoutMs,
+      pollMs: pollIntervalMs,
+      sleep,
+      dbg,
+    });
   }
 
   async function processPendingSdkSessionDeletes() {

package/.github/extensions/web-relay/skills/question-bridge.mjs

@@ -1,5 +1,5 @@
 import { getActiveSession } from '../runtime/session-registry.mjs';
-import { QUESTION_TIMEOUT_CONTINUATION_TEXT } from "../../../../shared/question-timeout.mjs";
+import { createRelayQuestion, waitForRelayQuestion } from "../../../../shared/question-wait.mjs";
 import { extractRequestedSchema } from "../../../../shared/question-schema.mjs";
 
 export function createQuestionBridge({
@@ -49,39 +49,18 @@ export function createQuestionBridge({
     return Number.isFinite(fallback) && fallback >= 0 ? fallback : 0;
   }
 
-  async function waitForRelayQuestionAnswer(questionId, timeoutMs = null) {
-    const started = Date.now();
-    const effectiveTimeoutMs = resolveQuestionWaitTimeoutMs(timeoutMs);
-
-    while (true) {
-      const { question } = await api("GET", `/api/relay-question/${questionId}`);
-      if (!question) throw new Error("Relay question missing");
-      if (question.status === "answered") {
-        return {
-          answer: String(question.answer || ""),
-          structuredAnswer: question.structuredAnswer && typeof question.structuredAnswer === "object"
-            ? question.structuredAnswer
-            : null,
-          timedOut: false,
-        };
-      }
-      if (question.status === "timed_out" || question.status === "cancelled") {
-        return {
-          answer: QUESTION_TIMEOUT_CONTINUATION_TEXT,
-          structuredAnswer: null,
-          timedOut: true,
-        };
-      }
-      if (Date.now() - started >= effectiveTimeoutMs) {
-        await api("POST", `/api/relay-question/${questionId}/timeout`, {}).catch(() => {});
-        return {
-          answer: QUESTION_TIMEOUT_CONTINUATION_TEXT,
-          structuredAnswer: null,
-          timedOut: true,
-        };
-      }
-      await sleep(questionPollMs);
-    }
+  // The wait survives a relay that is briefly not there
+  // (shared/question-wait.mjs).
+  function waitForRelayQuestionAnswer(questionId, timeoutMs = null) {
+    return waitForRelayQuestion({
+      api,
+      questionId,
+      deadlineMs: resolveQuestionWaitTimeoutMs(timeoutMs),
+      pollMs: questionPollMs,
+      sleep,
+      trimAnswer: false,
+      dbg,
+    });
   }
 
   async function forwardRelayQuestion(request) {
@@ -112,11 +91,7 @@ export function createQuestionBridge({
       request: serializeRequest(request),
     };
 
-    const created = await api("POST", "/api/relay-question", questionPayload);
-    const questionId = created?.question?.id;
-    if (!questionId) {
-      throw new Error("Relay question could not be created");
-    }
+    const questionId = await createRelayQuestion({ api, payload: questionPayload, sleep, dbg });
 
     dbg(
       "relay question created",

package/CHANGELOG.md

@@ -5,6 +5,205 @@ All notable changes to OAR are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.9.6] — 2026-09-29
+
+Highlights: a Claude turn pauses at the usage limit and carries on after the
+reset, a command that prints nothing no longer fails its turn, and agents on
+paired relays can work with each other for a whole session.
+
+### Added
+
+- The relay keeps a copy of its console in `relay-console.log` in its log
+  folder (`server/logs` unless you moved it), with a time stamp per line. The
+  file is rotated at 5 MB and three older copies are kept. The relay's token is
+  never written to it. Set `OAR_NO_CONSOLE_LOG=1` to switch it off.
+- **Claude usage limit:** a Claude turn that runs into the subscription's
+  usage limit is paused instead of failed. Your message closes with a note,
+  the relay queues a message of its own ("continue where you left off") and
+  sends it a minute after the limit resets. A banner above the composer says
+  when, with **Resume now** and **Cancel**. The pause survives a relay
+  restart. A reset more than six hours away (a weekly limit) waits for you to
+  resume it.
+- A banner warns in Claude conversations when the usage passes 90 % of a
+  limit, with the time of the reset, and can be hidden until the next one.
+
+### Changed
+
+- **Remote relays:** agents on paired relays can now work with each other for
+  a whole session. A relay you mentioned stays in reach whatever prompts arrive
+  later, and a relay whose agent wrote to a conversation is open to it, so the
+  agent that was asked can answer, ask back or report later. Until now a prompt
+  from another relay's agent took the tool away for the rest of the turn, also
+  in a turn you had started yourself. A prompt that crossed two relays is still
+  not passed on to a third relay you did not unlock; reading and waiting are no
+  longer limited. After 30 prompts to other relays' agents without a message
+  from you, the next one asks you first.
+- Subagents are folded to their header inside the running turn, so a turn with
+  many of them stays short to scroll. The header says how many steps the
+  subagent has taken and shows the latest one, as far as there is room. A tap
+  on the header unfolds a subagent and folds it again; what you chose by hand
+  stays. The Stop button of a finished subagent is gone.
+- **Copilot, Cursor, Grok:** how long a turn may stay quiet now depends on what
+  the agent is doing: 2 minutes with nothing in flight, 5 minutes during a model
+  request, 30 minutes while a tool runs. Until now every silence of 2 minutes
+  failed the turn, including a command that simply printed nothing. The failure
+  note says how long the silence was and what was running. The three windows can
+  be set with `OAR_TURN_STALL_IDLE_MS`, `OAR_TURN_STALL_MODEL_MS` and
+  `OAR_TURN_STALL_TOOL_MS`.
+- **Copilot:** a turn kept past 2 minutes of silence is checked: a runtime that
+  no longer answers fails the turn at once. The watchdog also covers the start of
+  a session, where a runtime that did not answer used to hold the message without
+  any failure, and a Stop during that start now takes effect at once.
+- **Cursor:** a stalled run is cancelled, so the next message does not wait for
+  it.
+- A plan board is part of the reply it belongs to: its content and its buttons
+  are shown inside the agent's reply bubble (inside the running turn's bubble
+  until the reply is there) instead of on a card of their own at the end of the
+  transcript. When the reply already is the plan, the plan is shown once, with
+  the buttons below it. After you chose, the plan stays and the bubble says
+  what was chosen.
+- The choice on a plan board also sets the mode of the session: after
+  "Implement in autopilot" the composer says Autopilot, after "Stop here and
+  prompt myself" it says Agent, and the next message carries the work on. The
+  session used to stay in Plan, so the next message planned again. "Stop here"
+  leaves the mode as it is.
+
+### Fixed
+
+- A session worker that was idle and whose process has ended (stopped from
+  outside, or crashed between turns) is no longer listed as ready with its old
+  process id. The next message started a new worker before as well; the list
+  now says what is there, about a minute and a half after the process ended.
+- A reply that quotes or describes a failure note (an agent reporting on a
+  failed test, for example) is no longer taken for a failure itself. The relay
+  cut such a reply off at the quoted error code, put its own advice behind it
+  and stored the turn as failed. Where a failure is known from its text alone,
+  that text is now kept whole.
+- A single `~` in a reply ("about", as in "~35 s … ~7 min") no longer strikes
+  out the text up to the next one. Strikethrough needs two tildes on each side:
+  `~~text~~`. The page now names the version of its Markdown library (15.0.12,
+  the one it was served until now) instead of taking whatever the CDN hands out.
+- **Copilot:** a command the agent had started no longer runs on after its
+  runtime is gone. When the runtime died or was killed in the middle of a turn,
+  the turn failed as it should, but the command kept running with nobody left
+  to read its result. The relay now stops what such a runtime leaves behind
+  (first gently, then by force), and the failure note says that a command that
+  was still running is being stopped, as far as that is known at that moment:
+  the note comes at once and does not wait for the list of processes. A command
+  the agent started to outlive the session (`detach`) is left alone, and so are
+  the commands of a runtime that shuts down in good order.
+- **Grok:** a quiet-turn window that is set for the model request or for a tool
+  is kept when the shared watchdog is switched off by the environment, and the
+  watchdog looks often enough for the shortest window that is set.
+- **Windows:** stopping or deleting a session could end the worker of another
+  session as well. Windows hands the process id of an ended process out again,
+  and a worker whose creator was long gone could so look like a child of the
+  session that was being stopped. A process older than its parent is no longer
+  taken for its child, and the worker of another session never is.
+- **Copilot:** a message sent while a command is running no longer cuts the
+  command short. It waits until the running tool call has ended and is steered
+  in then; the composer reads "Queue" for as long. Sent at once, the message
+  made the runtime push the command to the background: the turn ended early
+  with the answer to the new message alone, or failed with "No response was
+  returned", and the command's result arrived later in a turn of its own.
+- A plan board's action ("Implement in autopilot" and the like) queues its
+  follow-up again. It failed with an error and left the board marked as acted
+  on, without the message that carries the plan out.
+- A finished subagent no longer turns back to "Running" in the running turn
+  when another line of activity arrives or the page reloads.
+- **Previews:** the first page load after a dev server was restarted no longer
+  ends in "The upstream connection failed: ECONNRESET". The preview lane keeps
+  its connections to the dev server, and the one it had kept was closed by the
+  restart. A request without a body is now sent once more on a connection of
+  its own: it reaches the restarted server, or the page says that nothing is
+  listening on the port.
+- Links in the file viewer and in plan boards have a colour that can be read in
+  dark mode; they used the browser's default blue.
+- A question or approval card no longer answers itself when the relay is
+  briefly unreachable, for example while it restarts. One failed check used to
+  end the wait: the agent was told to use its own judgement, or the approval
+  was refused, while the card stayed on screen. The wait now lasts through the
+  outage, for every provider.
+- **Copilot:** a turn that fails is reported at once. The failure used to wait
+  for the runtime to finish stopping, which took three minutes on a runtime that
+  had stopped answering; stopping it is now bounded, and the next message waits
+  for it before a new runtime starts.
+- **Copilot:** a failed turn keeps what the agent had written, above the failure
+  note. The note says how many tool calls ran and that their changes are still in
+  place, and it no longer advises restarting the relay. A message steered into
+  the failed turn gets a short marker with Resend instead of a second copy of
+  the failure.
+- **Copilot:** a slow relay no longer makes a busy runtime look silent.
+- **Copilot:** a reply the relay could not take (it was restarting, the
+  connection was reset) is offered again for up to five minutes. One failed
+  attempt used to put the message back in the queue, which threw the finished
+  answer away and ran the prompt a second time. A reply that cannot be saved at
+  all ends as a failure that says so, and nothing is run twice.
+- **Copilot:** what the agent does by itself after a background task (a
+  continuation) is kept while the relay restarts. Its row was given up after
+  about a second, and the whole reply with it.
+- **Copilot:** a relay that accepts live output and does not answer no longer
+  holds the turn: a live update waits 10 seconds at most, and after one that
+  ran out, live updates are skipped for 30 seconds. Tool lines skipped then are
+  missing from the transcript; the reply is not affected.
+- **Copilot:** Stop works on a turn that is stuck. A runtime that does not
+  answer the Stop within 10 seconds is ended with the turn, and a turn the user
+  stopped ends as stopped even when the runtime died or went silent after it.
+- **Copilot:** a runtime that exits, or stops answering, while the agent works
+  by itself after a background task is cleared away; the next message used to
+  fail on it. A lost connection during a model change is reported as that, not
+  as "pick another model".
+- **Copilot:** a failed turn tells its failure once. A message sent into the
+  turn that the agent had not started on gets the short marker with Resend,
+  like one it had taken in.
+- **Copilot:** background agents and shells are no longer closed with the
+  runtime because its list of them could not be read.
+- **Stop button:** Stop keeps working for a message that waits on a question
+  card while the agent starts and finishes other work, and for a second message
+  stopped while the same turn goes on. It used to do nothing in both cases.
+- **Copilot:** a turn the runtime itself ended with an error no longer tells
+  you to restart the relay. The worker starts a fresh runtime by itself; a
+  restart repairs nothing and costs every other running session.
+- The note under a failed turn no longer advises restarting the relay: a restart
+  repairs nothing there and interrupts every other running session. It now says
+  to send the message again and to include the error code in a report.
+- **Claude:** a turn the Claude account refuses (billing, an expired sign-in,
+  access the organisation has switched off) says to check the account or to sign
+  in again in Settings → Providers → Claude, with a button that opens the panel,
+  instead of "Retry the message". Its error code names the failure, for example
+  `relay.claude-billing-error`; it used to read `relay.claude-success`.
+
+## [0.9.5] — 2026-09-27
+
+Highlights: a Claude reply on the wrong row no longer blocks the conversation,
+workers on Windows write a log, and agents can set the effort of a session on
+another relay.
+
+### Added
+
+- **Remote relays**: an agent can set the reasoning effort of a session it starts or
+  prompts on another relay (`effort` on `create_session` and `send`), and `relay_info`
+  lists the efforts each model there takes.
+
+### Changed
+
+- Session workers on Windows now write the same `worker-<session>.log` as on
+  Linux, in the relay's log directory; the console window keeps showing the
+  output.
+
+### Fixed
+
+- **Remote relays:** waiting for a remote agent's reply no longer stops at an
+  interim answer ("still waiting for …") while the agent goes on in a turn of
+  its own without a background task, for example while its subagents work.
+- A Claude reply published as a *background continuation* instead of under
+  your message no longer blocks the conversation for up to 5 minutes: after
+  about 45 seconds of silence your message closes with a small muted note
+  naming that reply, and the next message runs normally. The note sends no
+  second notification, and an agent on a paired relay receives the reply
+  itself, not the note. A stray re-init of the Claude CLI between turns no
+  longer sends the reply there in the first place.
+
 ## [0.9.4] — 2026-09-27
 
 Highlights: remote relays (pair OAR relays and let an agent on one work on the

package/README.md

@@ -78,7 +78,7 @@ curl -fsSL oar.sh/install | sh
 The script checks for Node.js 22.13 or newer, runs `npm install -g @oar-sh/oar`, and then hands off to `oar setup` (with `--defaults` when there is no terminal to ask questions in). It refuses to run as root, because OAR installs per user. `OAR_VERSION=x.y.z` pins a version, `OAR_CHANNEL=beta` follows the beta channel, and `OAR_DRY_RUN=1` only prints what it would do:
 
 ```bash
-curl -fsSL oar.sh/install | OAR_VERSION=0.9.4 sh
+curl -fsSL oar.sh/install | OAR_VERSION=0.9.6 sh
 ```
 
 Read it before you run it: [oar.sh/install](https://oar.sh/install).
@@ -89,7 +89,7 @@ Read it before you run it: [oar.sh/install](https://oar.sh/install).
 irm oar.sh/install.ps1 | iex
 ```
 
-The PowerShell installer (PowerShell 5 or newer) does the same: it checks Node.js, runs `npm install -g @oar-sh/oar`, then `oar setup`. It reads the same `OAR_VERSION`, `OAR_CHANNEL`, and `OAR_DRY_RUN` variables, for example `$env:OAR_VERSION = '0.9.4'` before the command.
+The PowerShell installer (PowerShell 5 or newer) does the same: it checks Node.js, runs `npm install -g @oar-sh/oar`, then `oar setup`. It reads the same `OAR_VERSION`, `OAR_CHANNEL`, and `OAR_DRY_RUN` variables, for example `$env:OAR_VERSION = '0.9.6'` before the command.
 
 ### npm
 
@@ -326,6 +326,22 @@ Use **🤗 Select Models** to choose which variants show up in the composer, the
 
 ## Highlights
 
+### 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.
+- **A quiet command no longer fails its turn** (Copilot, Cursor, Grok): how long a turn may stay silent depends on what the agent is doing: 2 minutes with nothing in flight, 5 minutes during a model request, 30 minutes while a tool runs.
+- **Copilot turns that fail, fail well**: the failure shows at once, what the agent had written stays above the note, Stop works on a stuck turn, a finished reply survives a relay restart, and the commands of a runtime that died are stopped. A message you send while a command runs waits for the command instead of cutting it short.
+- **Agents on paired relays can answer each other**: a relay you mentioned stays in reach for the whole session, and an agent that was asked from another relay can answer, ask back or report later. See [Remote relays](#remote-relays).
+- **Less scrolling in a running turn**: subagents are folded to a one-line header that says what they are doing, and a plan board sits inside the reply it belongs to; its choice also sets the session's mode.
+- **Failure notes that help**: no more advice to restart the relay, and a Claude account problem (billing, sign-in, access) says what to check. The relay keeps its console in `relay-console.log`.
+
+### New in 0.9.5
+
+- **A misplaced Claude reply no longer blocks the conversation**: when a reply is published as a *background continuation* instead of under your message, the message closes after about 45 seconds of silence with a small note naming that reply, and the next message runs normally. It used to hold every later message for up to 5 minutes.
+- **Effort for remote sessions**: an agent can set the reasoning effort of a session it starts or prompts on another relay; a new session takes the calling session's effort when the model there supports it. See [Remote relays](#remote-relays).
+- **Waiting on another relay is steadier**: the wait no longer stops at an interim answer while the remote agent goes on in a turn of its own, for example while its subagents work.
+- **Worker logs on Windows**: session workers now write the same `worker-<session>.log` as on Linux, in the relay's log directory, while the console window keeps showing the output.
+
 ### New in 0.9.4
 
 - **Remote relays**: pair two OAR relays in **Settings → Relays** by pasting the other relay's web address; the pairing works both ways. An agent in any session can then work on the other relay when you ask it to: list and read its sessions, prompt one, start a new one, wait for the reply, and pass a question the remote agent asks back to you. See [Remote relays](#remote-relays).
@@ -442,7 +458,9 @@ 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**, 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**, **🖥️ 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**.
+
+**💤 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.
 
 ## Settings and configuration reference
 
@@ -539,6 +557,8 @@ The config file is `server/config.json` in a git checkout and `~/.oar/config.jso
 | `COPILOT_WEB_RELAY_LOG_DIR` | Log directory |
 | `OAR_STATE_ROOT` | State root of a global install, instead of `~/.oar` / `%APPDATA%\oar` |
 | `OAR_NO_UPDATE_CHECK=1` | Never contact oar.sh, not even for a manual update check |
+| `OAR_HOST_SUSPEND_DRY_RUN=1` | **Suspend host** logs the suspend instead of sleeping the machine |
+| `OAR_MCP_SERVER=0` | Do not attach OAR's MCP server to Grok and the Copilot extension engine; they get the preview instructions as text again, and no `remote_relay` tool |
 | `COPILOT_SDK_PATH` | The Copilot CLI runtime's `copilot-sdk` directory, instead of the newest one in the CLI's package cache |
 | `COPILOT_PKG_DIR` | An additional Copilot CLI package cache to search |
 | `GH_TOKEN`, `GITHUB_TOKEN` | GitHub token for the Copilot usage card, instead of `gh auth token` |
@@ -666,14 +686,23 @@ locked in a conversation until you mention it in one of your messages: type `@`
 from the list, or write its name or its host name. An IP address or `localhost` never counts as a
 host name; a relay whose name is itself an address is unlocked only with a leading `@`. The
 mention unlocks that relay for the rest of
-the conversation. Prompts that arrive from another relay's agent never unlock anything, and a
-chain of relays prompting relays stops after two hops.
+the conversation, whatever prompts arrive in it later.
+
+**Agents can answer each other.** When an agent on a paired relay writes to a conversation, that
+relay is open to the conversation from then on, within what **Agents may** allows, so the agent
+that was asked can answer, ask back or report later. A prompt from an agent never unlocks any
+other relay. A prompt that already crossed two relays is not passed on to a third one unless you
+unlocked that relay yourself; reading and waiting are never limited. When the agent of a
+conversation has sent 30 prompts to agents on other relays without a message from you, the next
+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
 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.
+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.
 
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oar-sh/oar",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "type": "module",
   "description": "OAR — Open Agent Relay: drive your local coding agents from any browser",
   "license": "MIT",
@@ -30,6 +30,7 @@
     "server/uploads/image_input.md",
     "shared/",
     "!shared/**/*.test.mjs",
+    "!shared/**/*-test-harness.mjs",
     "!shared/**/fixtures/",
     ".github/extensions/web-relay/",
     "!.github/extensions/web-relay/**/*.test.mjs",

package/server/claude-worker/claude-remote-relay-tool.mjs

@@ -63,6 +63,7 @@ export const REMOTE_RELAY_TOOL_ZOD_SHAPE = {
   model: text('model'),
   cwd: text('cwd'),
   mode: choice('mode', REMOTE_RELAY_MODES),
+  effort: text('effort'),
   title: text('title'),
   question_id: text('question_id'),
   answer: text('answer'),