@oar-sh/oar 0.9.2 → 0.9.4

package/.github/extensions/web-relay/extension.mjs

@@ -97,7 +97,12 @@ const bannerStateStore = createBannerStateStore({
 
 const buildPromptWithRelayContext = createRelayPromptBuilder({
   toolInstructions: RELAY_TOOL_INSTRUCTIONS,
-  getPreviewInstructions: createPreviewInstructionsProvider({ api }),
+  // With the OAR MCP server attached (session-worker-launch-service sets the
+  // flag), the CLI has a real `preview` tool: the HTTP-API instructions would
+  // only contradict it, so the section is dropped.
+  getPreviewInstructions: process.env.OAR_MCP_SERVER_ATTACHED === "1"
+    ? null
+    : createPreviewInstructionsProvider({ api }),
 });
 
 const managedServerLifecycle = createManagedServerLifecycle({

package/.github/extensions/web-relay/skills/tool-activity.mjs

@@ -3,6 +3,8 @@ import {
   formatToolResultActivity as formatSharedToolResultActivity,
   formatVoteMemoryActivity,
 } from "../../../../shared/tool-activity.mjs";
+import { isRemoteRelayToolName } from "../../../../shared/remote-relay-tool-core.mjs";
+import { summarizeRemoteRelayCall } from "../../../../shared/remote-relay-contract.mjs";
 
 export function normalizeActivityText(value, maxToolDetailLength = 140) {
   const text = String(value || "").trim();
@@ -133,6 +135,11 @@ export function formatToolActivity(request, maxToolDetailLength = 140) {
   if (lower.includes("report_intent")) {
     return detail ? `● ${detail}` : "● Working…";
   }
+  // The OAR MCP server's tool reaches the CLI as `oar-remote_relay`: show the
+  // same line every other engine writes for it.
+  if (isRemoteRelayToolName(rawName)) {
+    return `Tool (remote_relay): ${summarizeRemoteRelayCall(toolArgsSnapshot(request))}`;
+  }
   return detail ? `Tool (${rawName}): ${detail}` : `Tool (${rawName})`;
 }
 

package/CHANGELOG.md

@@ -3,6 +3,342 @@
 All notable changes to OAR are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow semver.
 
+## [Unreleased]
+
+## [0.9.4] — 2026-09-27
+
+Highlights: remote relays (pair OAR relays and let an agent on one work on the
+other), follow toggles for the running reply, and a Suspend host that waits for
+agents, background tasks and CI to finish.
+
+### Added
+
+- **Remote relays**: pair OAR relays in **Settings → Relays** by pasting the other
+  relay's web address; the pairing works both ways. Agents of every provider get a
+  `remote_relay` tool to list and read the other relay's sessions, prompt one, start
+  a new one, wait for its reply and relay its questions to you. A relay unlocks in a
+  conversation only once you mention it (`@` picks it from a list). Per relay, agents
+  may read, prompt or do everything; in ask and plan mode each write action asks you
+  first. The receiving relay marks such messages with a **↗ from …** badge. Tokens
+  stay on the relay; agents never see them.
+- **OAR MCP server** (`server/mcp/oar-mcp-server.mjs`): Grok and the Copilot
+  extension engine now get the `preview` and `remote_relay` tools as real tools
+  instead of instruction text.
+- **Follow the live reply**: three toggles in the running reply's header keep
+  its thoughts, its answer or its tool list pinned just above the composer as
+  the reply grows. Scrolling the transcript by hand turns it off; typing in the
+  composer does not. The choice is remembered per conversation until the page
+  reloads.
+- A queued relay restart shows a banner on every client, with a **Cancel**
+  button (a new localhost-only cancel endpoint behind it).
+
+### Changed
+
+- **Suspend host waits for the work to finish.** Instead of sleeping the
+  machine at once, the relay 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 a busy conversation's
+  repository (read through `gh`; a repository whose state cannot be read blocks
+  for 15 minutes, then is ignored). With nothing running at confirm time it
+  fires after a 30-second countdown. The confirmation lists what is still
+  active, every client shows a banner with the blockers or the countdown and a
+  **Cancel** button, and a push notification reports the suspend, or its drop
+  when the relay restarts. Suspend remains Windows-only;
+  `OAR_HOST_SUSPEND_DRY_RUN=1` logs instead of suspending.
+- **Stop** asks for confirmation before cancelling the running turn.
+- The **Install app name** setting is now called **Relay name**. Your value is
+  kept. It still labels the installed app, and it is the name paired relays
+  know this relay by; when it is empty, paired relays see the machine's
+  hostname.
+- Dependency updates clear all five `npm audit` findings, one of them rated
+  high: express 4.22.3, body-parser 1.20.8, qs 6.16.0, fast-uri 3.1.8 and
+  hono 4.13.9. All were inside the declared ranges, so `package.json` is
+  unchanged; a git checkout gets them with `npm ci`.
+
+### Fixed
+
+- Switching the Claude model in a conversation that already had replies no
+  longer strands the next message. The reply to the message that carried the
+  switch landed on a *continuation* row while the message itself stayed
+  processing, and every later message waited behind it for up to 5 minutes, or
+  until the session was killed.
+- **Requests on an idle connection are no longer reset.** The relay closed a
+  kept-alive connection after 5 seconds without traffic, so a request sent on
+  it a moment later could be reset before the relay read a byte. Behind a
+  reverse proxy or tunnel that pools its connections this showed up as an
+  occasional 502, and a send was not repeated. Idle connections now stay open
+  for 65 seconds.
+- After a send, the transcript stays at the newest message when the composer
+  grows (a session note or a warning banner appearing under it). It used to
+  slip up until the draft was saved.
+
+## [0.9.3] — 2026-09-27
+
+Highlights: mid-turn steering on Claude and Copilot, Copilot background tasks on
+par with Claude's, multi-select question cards, drafts that stay safe across
+devices, and a sidebar title filter.
+
+### Added
+
+- **Mid-turn steering** for Claude conversations: messages sent while a turn is
+  running are pushed into the live turn (any number of them — Claude Code
+  parity) instead of queueing behind it. Folded messages settle with a compact
+  *merged* marker; a message the CLI answers on its own turn gets its real
+  reply as before.
+- A **conversation title filter** above the sidebar list. Case-insensitive,
+  clears with × or Escape, and automatically loads older pages while active so
+  it searches every conversation, not just the loaded ones.
+- **Resend** on a steered message that was cut off by **Stop**: the marker
+  reads *Stopped with the turn — not answered* and one tap sends the original
+  text and attachments again. Each original can be resent once (again only if
+  that Resend was cancelled or failed), and the button reads **Resent** on
+  every device and after reloads.
+- The running reply's **Stop** header stays pinned at the top of the chat
+  while a long reply scrolls, so it is always in reach on a phone.
+- Background subagents in the task panel show the **model they actually run
+  on** (e.g. *Opus 5.5*) beside their kind pill, and the **command they are
+  running right now** with its tool emoji (e.g. *🔧 Tool (Bash): npm test*),
+  cropped to the row — instead of *using Bash · opus*.
+- **Mid-turn steering for Copilot conversations** (SDK engine, hosted and
+  BYOK alike, every Copilot model): a message sent while a turn runs is
+  pushed into the live turn. The runtime folds it in at the next tool boundary
+  (the message settles with the same *merged* marker as on Claude, and the
+  reply continues in the running bubble) or, when the model is mid-sentence,
+  answers it right after on its own bubble. The composer reads **Steer** for
+  these conversations; while a question card, approval, elicitation or a
+  compaction is open it reads **Queue** and the message waits in the queue,
+  cancellable, then steers in one round-trip after the answer. **Stop** now
+  ends only the reply — background agents the turn started keep running under
+  their own Stop — and messages pushed just before the Stop settle as *Stopped
+  with the turn — not answered* with **Resend**, exactly as on Claude.
+- Messages steered into a running turn (Claude and Copilot) carry a short
+  hidden note telling the model to handle them in addition to the request it
+  is working on. In testing, a model that received a steer before its first
+  output answered only the new message and dropped the original request.
+- The newest message you steered into a running Copilot turn keeps its
+  **Cancel** until the runtime picks it up: cancelling pulls it back out of the
+  runtime, so it is never answered. (Copilot's queue can only give back its
+  newest waiting message, so older ones lose Cancel once pushed, as on Claude.)
+- **Background tasks for Copilot conversations** now match Claude's: background
+  agents the model spawns and detached shells appear in the task panel as they
+  run, with the agent's kind, the model it runs on, the command it is running
+  right now, its token count and a **Stop** that works (the runtime's task
+  registry). A reply no longer waits for a background agent to finish; the
+  agent's result arrives afterwards as its own *continuation* reply, and the
+  relay's *Background task timeout* slider now governs Copilot tasks too
+  (expiry stops them instead of silently forgetting them).
+- **Multi-select question cards.** A question that allows several answers
+  renders checkmarks instead of one-shot buttons, plus one **Reply with
+  selection** button; the reply lists every ticked choice and whatever you
+  typed in addition. Previously the first click answered the whole card.
+  Claude cards follow Claude's own `multiSelect` flag. Copilot models get the
+  relay's own `ask_user` tool, which adds a `multi_select` field to the
+  runtime's (the built-in has no way to say "pick several"); a question worded
+  "select all that apply" counts too, and every Copilot choice card has a
+  **Select several** switch for the cases a model forgets to flag.
+
+### Changed
+
+- Copilot replies settle when the main agent goes idle rather than when the
+  whole session does, so a background agent the turn spawned no longer keeps
+  the reply's bubble spinning for as long as it runs; the agent's own
+  follow-up arrives as a *continuation* reply, as on Claude. A background agent
+  that asks a question, or in ask mode asks to run something, after the reply
+  settled gets its card on a row of its own; approvals follow the
+  conversation's current mode, not the one the session started in. A
+  follow-up turn that ends with nothing to show (no text, and no activity
+  beyond the background agent's own bookkeeping, such as its granted
+  permissions) no longer leaves an empty "completed without a text reply"
+  row. Messages
+  are sent to the Copilot runtime as `immediate` throughout — the only mode
+  that never strands a message behind background work.
+
+- The background task panel scrolls when it holds more tasks than fit,
+  instead of growing past the window — in phone landscape too, where the
+  composer now always stays on screen.
+- The **Background task timeout** setting defaults to **4 hours** instead of
+  no limit, for Claude and Copilot alike: long-running work still finishes,
+  but a forgotten shell or agent no longer keeps its session alive forever.
+  A value you already chose (including *No limit*) is kept.
+- Rotating a phone to landscape keeps the portrait text size instead of
+  jumping to the larger desktop size, and opening the on-screen keyboard
+  no longer shrinks it.
+- Rotating a phone (or resizing the window, or opening the keyboard) keeps
+  your place in the transcript: a reader at the end stays at the end, and
+  mid-history the same message stays at the top of the screen. Previously
+  the reflow left you screens above where you were, usually further back.
+  A question card's reply box you are typing in stays in view when the
+  keyboard opens.
+
+- The composer's send button no longer turns into **Stop** while a turn runs.
+  It reads **Steer** when a Claude turn is live and text is drafted, and stays
+  disabled on an empty composer. While steering is held (open question card or
+  plan approval, compaction) it stays enabled and reads **Queue**, with the
+  reason in its tooltip: the message waits as an ordinary pending bubble (with
+  **Cancel**) and steers into the turn once the card is answered or the
+  compaction ends. Stopping lives where the work is: the running reply's bubble
+  carries **Stop**, and queued messages carry **Cancel** until they are picked
+  up. The label follows the worker within about a second, including right
+  after a worker starts or the relay restarts.
+- Queued messages are claimed strictly in send order, including messages that
+  went through a delivery retry. Previously a retried message could starve
+  behind newer ones for minutes in an active conversation, or run after them
+  so replies arrived out of order.
+- `@anthropic-ai/claude-agent-sdk` 0.3.283 (bundled Claude Code 2.1.283),
+  which makes **Claude Opus 5.5** (`claude-opus-5-5`, plus its 1M-context
+  variant) discoverable. Model discovery runs the SDK's bundled CLI, so
+  `claude update` alone never surfaces a new Claude model.
+- `@github/copilot-sdk` 1.0.14: typed message provenance (human vs. system vs.
+  agent senders), a `fast` auto-routing tier, a `managedSettings.clearCache`
+  RPC, and streaming-throughput fixes.
+- `@cursor/sdk` 1.0.32 (additive API changes only).
+- The npm package no longer ships test fixtures and test harnesses.
+- The README is reorganized around installing and using OAR; relay internals
+  and development notes moved to DEVELOPING.md.
+
+### Fixed
+
+- **Deleting a conversation no longer leaves its session running.** Its
+  worker used to keep running (about 40 MB each, holding its workspace
+  folder) until the relay restarted, and Claude and Copilot SDK
+  conversations never had their CLI session removed. Delete now stops the
+  worker first, removes the CLI session (Copilot through the SDK, Claude by
+  deleting that session's transcript) and the conversation at once. A
+  Copilot session the relay only imported from the host, and never ran, is
+  hidden instead: its CLI session stays, and no process is stopped for it. A
+  conversation that is still working, with a running turn or live background
+  tasks, is not deleted: the sidebar says why, so you can stop it first (a task
+  without a Stop button: use **Kill session**). A worker that a failed turn
+  marked as errored counts as working for as long as its process runs.
+- A message starting with "/" (other than the relay's own `/compact` and
+  `/preview`) that reached a Claude conversation between turns ran as a Claude
+  CLI command instead: Claude never saw the text, and the next reply was
+  pinned to that message. It now reaches Claude as the text you typed, as the
+  composer's "send again to send as text" promises.
+- A Copilot turn that ended in `task_complete` after streaming a fragment
+  published the fragment as its final reply; the completion summary now takes
+  precedence in the saved reply too, not only in the live stream.
+- A background subagent's own events could open a spurious *continuation*
+  reply after the Copilot turn that spawned it had settled, and its
+  session-level model notice could confuse a pending model switch.
+- Switching the model, mode or effort between turns no longer strands the
+  next message: the Claude CLI re-initialises after such a change, and the
+  worker took that for a turn it opened on its own, so the reply landed on
+  a *continuation* row while the message itself stayed processing with an
+  empty Stop bubble (until the session was killed). A background task's reply
+  that arrives during such a switch still gets its own row instead of
+  trading places with the message's reply.
+- A steered message could wedge its conversation indefinitely when a
+  long-running (or hung) background task was alive: the merge settle waited for
+  a full idle that never came, keeping every later message stuck behind it.
+  Background tasks no longer block the settle; delivery watchdogs share the
+  same rule.
+- **Drafts no longer get overwritten across devices.** The draft version check
+  never actually ran, so an idle device re-saved its stale (usually empty)
+  composer over another device's draft every few seconds. Saves are now
+  version-checked and happen only on real edits; a device you are not typing
+  on picks up the other's draft, and when two devices edit at once the newest
+  keystroke wins and the other text is offered back with **Restore** (and
+  **Undo**).
+- Other ways to lose a draft are fixed too: text typed or attachments added
+  while a send was in flight, switching conversations mid-send or before the
+  next draft loaded, reopening the open conversation (which dropped its draft
+  attachments), a failed send overwriting what was typed meanwhile, and drafts
+  over 20,000 characters re-saving in a loop (the saved part is now cut
+  cleanly, and the composer says the rest is not saved).
+- A steered message could run twice: Claude had already answered it, but the
+  relay's recovery (or a worker crash or restart) delivered it again. Steered
+  messages are now handled at most once: if the outcome cannot be recorded, the
+  message ends with an error telling you to check the reply above rather than
+  being run again.
+- A message sent while a question card was open or the conversation was
+  compacting could stall for many seconds, or be pushed past the open card.
+  Question cards are never bypassed or dropped by steering: such messages wait
+  and steer in once the card is answered.
+- **Stop now really stops** when steered messages were already pushed into the
+  turn. The Claude CLI otherwise opened a follow-up turn for them that re-ran
+  the stopped tool call; those messages now show *Stopped with the turn — not
+  answered* with **Resend** instead of claiming they were handled. A stopped
+  message is also no longer re-run if its worker dies right after the Stop.
+- After a reload, a message sent after a folded steer is no longer styled as
+  steered with its reply merged into the previous turn, and older replies stay
+  anchored under their own messages.
+- The live reply bubble no longer carries over into another conversation or
+  drops below later steered messages, and the live bubble and **Stop** follow
+  the turn that is actually producing output. A finished background task's
+  answer is no longer lost when a queued message takes over the turn.
+- A screenshot-only send no longer vanishes from the transcript before its
+  message lands.
+- Sidebar filter: keeps searching older pages while the list is busy loading,
+  matches accented titles regardless of how they were typed, no longer zooms
+  the page on iOS, and announces the match count once to screen readers
+  (saying when only loaded conversations were searched).
+- A background agent's failure no longer vanishes: a Copilot follow-up turn
+  that carries the failure line, but has nothing else to show, keeps its row.
+- The **Background task timeout** slider no longer reads *No limit* while the
+  settings load; it starts at the 4-hour default.
+- Settings calls the SDK engine the Copilot default (it still read
+  *experimental*, with Extension as *current*), and the background task
+  timeout help names Copilot's background agents and shells.
+- `oar` probed a different port than the one it started the relay on when the
+  config's `port` was not 3333 or differed from `--port`, then killed the relay
+  it had just started after 20 seconds. It now uses one port: `--port` for that
+  run, else the config's. `--help` no longer lists `--token`, which the
+  launcher never read.
+- Concurrent conversation deletes could start extra Copilot runtimes that were
+  never shut down.
+- Question cards said *Copilot question* in every conversation; they now name
+  the runtime that asks (Claude, Copilot, Cursor, OpenAI).
+
+## [0.9.2] — 2026-09-13
+
+### Added
+
+- **Opt-in self-update**: a settings toggle for automatic update checks (off by
+  default; the relay never contacts oar.sh unless you opt in), plus a manual
+  check button. `OAR_NO_UPDATE_CHECK=1` disables even manual checks.
+- Agents can embed **images, video and audio inline** in replies by bare
+  absolute path, on every provider. Clicking an embedded image opens the file
+  viewer with zoom, download and copy.
+- **Screenshot annotations**: mark up uploaded screenshots with highlighter
+  strokes before (or after) sending; the original upload is never modified.
+- A **Features** settings tab; feature flags now live in the database (the
+  `config.json` `features` key is migrated once and removed; env vars still win).
+- Windows **system-startup autostart** mode (a boot-triggered scheduled task,
+  one UAC confirmation) alongside the existing at-sign-in mode.
+- `config.json` can carry the data directory.
+
+### Changed
+
+- New Copilot conversations default to the **SDK engine** when the relay can
+  run it, falling back to the CLI extension otherwise; an explicitly stored
+  setting always wins.
+- The Copilot model catalog shows each model's real reasoning efforts and
+  context window, in a canonical order.
+- Model labels are compact enough for phone composers (`Fable 5.1`,
+  `Haiku 4.5`), and the composer placeholder names the selected model's family.
+- Claude models stay in the picker when Anthropic rotates the advertised
+  lineup; `@anthropic-ai/claude-agent-sdk` 0.3.261 (Fable 5.1 model floor).
+- Global installs run from the OAR state root, so self-update can replace the
+  package directory on Windows.
+- Transient relay notices render as an opaque toast instead of bleeding
+  through modals.
+
+### Fixed
+
+- A custom PWA app name no longer reverts on Android: the relay serves it in
+  the manifest instead of a browser-local override.
+- Queue writes are fenced to one processing attempt, so a superseded delivery
+  can no longer overwrite a settled message.
+- Live-bubble rendering: cross-conversation teardown, muted streams after
+  enqueue, a live-poll deadlock and anchor theft.
+- A queued send's own text no longer reappears in the composer.
+- Copilot turns ending in a bare `task_complete` tool call show the real
+  summary instead of a cut-off fragment; detached Copilot shells appear as
+  background-task cards.
+- Copilot worker and server-side session ownership hardening (continuations,
+  questions, shutdown, rekeying, worker kill verification).
+
 ## [0.9.1] — 2026-09-02
 
 ### Fixed