@oar-sh/oar 0.9.12 → 0.9.14

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

@@ -13,6 +13,7 @@ import path from "path";
 import { generateHighEntropyToken } from "./utils/token-generation.mjs";
 import { delay, killProcessTree, sleep } from "./utils/process-utils.mjs";
 import {
+  carryOverPackageConfig,
   resolveRelayPaths,
   loadTokenFromConfig,
   loadRelayInstructionsFromFile,
@@ -60,7 +61,13 @@ const {
   LOG_DIR,
   SERVER_LOG_PATH,
   SERVER_ERR_PATH,
+  RELAY_ENV,
 } = resolveRelayPaths(import.meta.url);
+// A global install's config moves to the state root with the relay's data:
+// the one the package held before is copied there once (never over one).
+const CARRIED_OVER_CONFIG = RELAY_ENV.COPILOT_WEB_RELAY_CONFIG
+  ? carryOverPackageConfig({ serverDir: SERVER_DIR, configPath: CONFIG_PATH, dataDir: RELAY_ENV.COPILOT_WEB_RELAY_DATA_DIR })
+  : null;
 const SERVER_URL = resolveRelayServerUrl({ configPath: CONFIG_PATH });
 const SERVER_START_TIMEOUT_MS = 20_000;
 const NODE_BIN = process.env.COPILOT_WEB_RELAY_NODE || "node";
@@ -78,6 +85,7 @@ const MODEL_SNAPSHOT_MIN_INTERVAL_MS = 30_000;
 const BANNER_DEDUPE_TTL_MS = 6 * 60 * 60 * 1000;
 const BANNER_DEDUPE_COOLDOWN_MS = 15 * 1000;
 const { dbg } = createDebugLogger({ logDir: LOG_DIR });
+if (CARRIED_OVER_CONFIG) dbg("copied the relay config", CARRIED_OVER_CONFIG, "to", CONFIG_PATH);
 const api = createApiClient({
   serverUrl: SERVER_URL,
   token: TOKEN,
@@ -117,6 +125,7 @@ const managedServerLifecycle = createManagedServerLifecycle({
   serverDir: SERVER_DIR,
   serverLogPath: SERVER_LOG_PATH,
   serverErrPath: SERVER_ERR_PATH,
+  relayEnv: RELAY_ENV,
   relayPort: Number(new URL(SERVER_URL).port) || 3333,
   nodeBin: NODE_BIN,
   serverStartTimeoutMs: SERVER_START_TIMEOUT_MS,

package/.github/extensions/web-relay/server-lifecycle/managed-server.mjs

@@ -10,6 +10,9 @@ export function createManagedServerLifecycle({
   serverDir,
   serverLogPath,
   serverErrPath,
+  // The state root's folders a global install pins (resolveRelayPaths'
+  // RELAY_ENV); what the CLI's own environment names wins.
+  relayEnv = {},
   relayPort = 3333,
   nodeBin,
   serverStartTimeoutMs,
@@ -24,6 +27,9 @@ export function createManagedServerLifecycle({
   let restartTimer = null;
   let restartAttempts = 0;
   let attemptedSqliteRepair = false;
+  // The relay stopped on purpose (RELAY_STOP_EXIT_CODE): its reason is in
+  // its log, and starting it again at once cannot help.
+  let stoppedOnPurpose = false;
   // Keep in sync with server/relay-self-restart.mjs. Passing this on argv (not
   // in the env) is deliberate: this extension's own env is inherited from the
   // relay worker that launched the CLI, so an env flag here would be read by
@@ -33,6 +39,7 @@ export function createManagedServerLifecycle({
   const RESTART_BACKOFF_MS = [1000, 2000, 5000, 10000, 20000];
   // Keep in sync with server/relay-exit-codes.mjs
   const RELAY_RESTART_EXIT_CODE = 75;
+  const RELAY_STOP_EXIT_CODE = 78;
   const STARTUP_LOG_TAIL_BYTES = 24 * 1024;
   const STATUS_PATH = "/api/status";
   const RELAY_PORT = Number.isInteger(Number(relayPort)) && Number(relayPort) > 0
@@ -198,6 +205,7 @@ export function createManagedServerLifecycle({
   async function waitForServerReady(timeoutMs = serverStartTimeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
+      if (stoppedOnPurpose) return false;
       try {
         await api("GET", STATUS_PATH);
         return true;
@@ -280,12 +288,16 @@ export function createManagedServerLifecycle({
 
         dbg("starting managed web server", serverDir);
         managedServerOwned = true;
+        stoppedOnPurpose = false;
         startedOwnedProcess = true;
         const serverArgs = ["server.js", RELAY_SUPERVISED_FLAG, "--token", token];
         if (legacyOwnerPidWatchdog) {
           serverArgs.push("--owner-pid", String(process.pid));
         }
         const serverEnv = { ...process.env };
+        for (const [key, value] of Object.entries(relayEnv || {})) {
+          if (!String(serverEnv[key] || "").trim() && value) serverEnv[key] = value;
+        }
         if (startupWorkspaceRoot) {
           serverEnv.COPILOT_WORKSPACE_ROOT = startupWorkspaceRoot;
         }
@@ -300,13 +312,14 @@ export function createManagedServerLifecycle({
         managedServerProc.once("exit", (code, signal) => {
           const normalizedCode = Number.isInteger(Number(code)) ? Number(code) : null;
           const intentionalRestart = normalizedCode === RELAY_RESTART_EXIT_CODE;
+          stoppedOnPurpose = normalizedCode === RELAY_STOP_EXIT_CODE;
           dbg(
             "managed web server exited",
             `code=${code ?? "null"}`,
             `signal=${signal ?? "none"}`,
             intentionalRestart ? "intentionalRestart=true" : "intentionalRestart=false",
           );
-          const shouldRestart = desiredRunning && managedServerOwned && !stoppingManagedServer;
+          const shouldRestart = desiredRunning && managedServerOwned && !stoppingManagedServer && !stoppedOnPurpose;
           closeManagedServerStreams();
           managedServerProc = null;
           managedServerOwned = false;
@@ -357,6 +370,7 @@ export function createManagedServerLifecycle({
         closeManagedServerStreams();
         managedServerProc = null;
         managedServerOwned = false;
+        if (stoppedOnPurpose) markNonRetryable(error);
         if (desiredRunning && !stoppingManagedServer && error?.relayRetryable !== false) {
           scheduleManagedServerRestart("start-failed");
         }

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

@@ -77,7 +77,10 @@ export function createQuestionBridge({
       mode: activeMsg?.relayMode || "agent",
       prompt: extractQuestionPrompt(request),
       choices,
-      allowFreeform: allowFreeform ?? !choices.length,
+      // Free text unless the request says otherwise, as the runtime's ask_user
+      // and the SDK engine's bridge read it: the relay refuses typed text on a
+      // card sent with allowFreeform:false.
+      allowFreeform: allowFreeform ?? true,
       requestedSchema: requestedSchema || undefined,
       sdk_session_id: activeSession?.sdkSessionId || undefined,
       timeout_ms: questionTimeoutMs,

package/CHANGELOG.md

@@ -3,6 +3,514 @@
 All notable changes to OAR are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow semver.
 
+## [0.9.14] — 2026-10-21
+
+Highlights: a relay started by Windows autostart, or by a plain
+`gh copilot`, now runs on the same data folder as `oar start`, outside the
+installed package, so an update no longer takes its conversations with it;
+the update copies that data before npm removes the old version, and the
+relay takes it over at its next start (read the upgrade note first). A
+relay never moves to another database unannounced, a lock an unclean end
+left no longer blocks the next start, autostart waits for a late drive, and
+Cursor conversations keep their agent across updates. An agent can ask to
+be woken when the relay runs again (`relay_restarted`), its preview tool
+reaches only its own conversation's previews, approval cards take a choice
+instead of typed text, and a conversation whose folder is gone says so.
+
+### Upgrade notes
+
+- **Windows autostart users, and anyone whose relay a plain `gh copilot`
+  started: save your data before this update.** Before 0.9.14, those relays
+  ran on the database and uploads inside the installed package, and
+  `npm i -g` deletes them with the old version. This update copies them
+  first, while it installs, to `rescued-package-data/<time>/` in the OAR
+  data folder (`%APPDATA%\oar\data`, `~/.oar/data`), and the relay takes
+  the copy over at its next start. npm 10 and 11 run that copy (11.21 with
+  a warning), and if it fails they put the old version back with its data.
+  npm 12 skips it unless `@oar-sh/oar` is allowed: the install then
+  succeeds and the old data is gone. With `strict-allow-scripts`, npm 11
+  and 12 refuse the install and change nothing; `--ignore-scripts` skips
+  the copy everywhere, and the native modules (better-sqlite3, koffi) too,
+  so the relay cannot start afterwards: never update OAR with
+  `--ignore-scripts`. On npm 12, update with the relay stopped:
+  `npm i -g @oar-sh/oar --allow-scripts=@oar-sh/oar,better-sqlite3,koffi`.
+  An `allow-scripts` entry in `.npmrc` does not help the **Update** button
+  or `oar update` of 0.9.13: their own `--allow-scripts` replaces it. To be
+  safe, do this update by hand:
+  1. Close every `gh copilot` session (its extension starts the relay
+     again), then `oar stop`, and wait until `oar status` says it is not
+     running. If 0.9.13's `oar stop` does not stop a relay the
+     system-startup launcher started, end the relay before installing:
+     end the relay's processes in Task Manager (node.exe running OAR).
+  2. Run `npm root -g` and open `<that folder>/@oar-sh/oar/server`
+     (usually `%APPDATA%\npm\node_modules\@oar-sh\oar\server`). Copy
+     **both** the `data` and the `uploads` folders, with every file in
+     them, to a safe place.
+  3. `npm i -g @oar-sh/oar --allow-scripts=@oar-sh/oar,better-sqlite3,koffi`.
+  4. Before starting the relay, copy both folders back into the same
+     `server` folder.
+  5. `oar start`. In `relay-console.log` in the OAR `logs` folder, look
+     for `[data] Brought over the database …`: your conversations should
+     be back. A database that was already in the OAR data folder is kept
+     in `backups/<time>/` beside it. The folder brought over keeps its
+     database as `copilot.db.adopted-<time>`; the others looked at keep
+     theirs as `copilot.db.older-<time>` (if a rescue copy was used, the
+     package's own database ends up `.older-`).
+  6. If the relay stops with `[data] Not starting: each database has
+     changes newer than the other's`, both hold work; the error line names
+     both folders, and one may be under
+     `rescued-package-data/<time>/data`. Pick the one to keep, and move
+     the other one's `copilot.db`, `copilot.db-wal` and `copilot.db-shm`
+     into a folder of your own (do not delete them). Then `oar start`
+     again.
+  7. If you already updated without saving and nothing was copied, the
+     database from the package can't be recovered by OAR.
+- The npm package guard allows 8 MiB unpacked and 530 entries (was 7.75
+  MiB and 520); the take-over of earlier databases, the install-time copy
+  and the lock checks grew the package to about 7.75 MiB and 521 entries.
+
+### Added
+
+- **Woken when the relay runs again** (`relay_restarted`, opt-in per
+  conversation). A conversation that queued a relay restart, or watched
+  sessions, slept after the restart until someone wrote, because the timers
+  its CLI had scheduled might not survive it. An agent can now subscribe to
+  `relay_restarted` through `remote_relay` (no sessions needed, no approval
+  card, this relay only); after each start it gets one relay event with when
+  the relay came back and how it stopped (who requested the restart, when
+  and why, or that it did not record how it stopped). Never part of the
+  default events. A restart requested while a turn it woke still runs does
+  not wake that conversation (a one-shot subscription held back so ends),
+  archived and deleted conversations are not woken, and each start is told
+  once.
+
+### Changed
+
+- **Help texts and CLI messages say what the relay does.** **Accept prompts
+  from other relays' agents** lists everything it refuses when off, watching
+  sessions included; **Show Suspend host action** says it is a switch of this
+  browser and suspend works on Windows relays only; the Cursor session token
+  names the real usage bars; the Copilot engine applies whenever a
+  conversation's worker starts. `oar` points to **Settings → General →
+  Autostart (Windows)**, says the service starts again at boot with
+  lingering, sends a failed start or restart through the service to
+  `journalctl --user -u oar` instead of `server-err.log`, words a busy port
+  one way, and says an already running relay keeps its version and settings
+  until `oar restart`.
+- **Agent guidance.** The ask_user example in the Copilot engines' relay
+  guidance is a real question instead of quiz placeholders, the guidance and
+  the Cursor and Copilot ask_user descriptions give the choice counts the
+  relay accepts (it keeps the first 8), the remote relay section names every
+  subscription action and `usage`, and the restart note says a queued
+  restart waits for every running turn and holds new messages.
+- **Docs brought in line with the code**: the paired-relay switch, watch
+  approvals per relay, no push for agent-started turns, provider rebinding of
+  unstarted chats, OpenAI key removal, `oar stop`/`oar restart` under the
+  systemd service (they end running turns and workers), Claude turns on the
+  bundled Claude Code, the config keys and environment variables, which
+  variables reach workers started under tmux, the worker supervisor and the
+  database migrations.
+- **Uploads follow the config's `dataDir`.** It moved the database but
+  left uploads in `server/uploads` unless `COPILOT_WEB_RELAY_DATA_DIR` was
+  set; they now go to `<dataDir>/uploads` as well. Uploads earlier versions
+  left in `server/uploads`, or that a state migration copied into the state
+  root's `uploads/`, are still read from there in place: every attachment
+  opens after the update, and nothing in those folders is moved or deleted.
+- `@anthropic-ai/claude-agent-sdk` 0.3.304 (was 0.3.292; bundled Claude Code
+  2.1.304). Claude now forks sub-agents that inherit the conversation
+  (`subagent_type: "fork"`) by default. With thinking turned off, a model that
+  cannot run without thinking now uses adaptive thinking. A full disk during a
+  login refresh is reported as a failed request instead of a sign-in error.
+  Fixes include an approved tool call that could run twice on resume, model
+  switches and interrupts waiting behind a context-usage check, and
+  `hook_progress` messages piling up in memory.
+- `@cursor/sdk` 1.0.38 (was 1.0.36), which uses the relay's own `zod`
+  instead of carrying a copy of zod 3.
+- `@github/copilot-sdk` 1.0.23 (was 1.0.17; bundled Copilot CLI 1.0.100).
+  The Copilot workers and the web-relay extension are unchanged: under the
+  Copilot CLI both run the SDK that comes with the installed CLI. **About
+  OAR** shows the new version.
+
+### Fixed
+
+- **Windows autostart starts the relay on the same data as `oar start`.**
+  The sign-in entry and the system-startup launcher set only the config
+  file, so a relay they started kept its database, uploads and log inside
+  the installed package: other conversations and settings than with
+  `oar start`, and gone with the next update. Both now also set the data
+  and log folders `oar start` uses (`%APPDATA%\oar\data` and
+  `%APPDATA%\oar\logs` on a global install). Once it runs, the relay brings
+  an entry or launcher that an earlier version (0.9.0 on) generated for
+  this install and its config up to date, the pre-rebrand
+  `copilot-remote-web-relay.cmd` under its own name, so the first start
+  after the update (by `oar start`, `oar update` or the autostart itself)
+  repairs it. An entry edited by hand, one that points at another config
+  file, and one of a relay started on data folders of its own are left
+  alone: switch autostart off and on in Settings to replace those. Rewriting
+  a launcher while the relay it started still runs is safe: its cmd window
+  ends with the relay instead of starting it a second time. The launchers
+  now switch cmd to UTF-8, so a user folder with non-ASCII characters in its
+  name no longer garbles the paths in them. Conversations a relay started
+  by autostart kept inside the package folder are not carried over.
+- **A relay never moves to another database unannounced.** Before its own
+  database opens, a global install's relay pinned to the OAR data folder
+  looks once at each database it may have run on until now (the one inside
+  the package, the install-time copies of it): a newer one is copied in
+  after a `quick_check` of the copy, with the uploads and Cursor agent
+  stores (never over a file there), the older one in place is kept in
+  `backups/<time>/`, and one line says so. Each one looked at is renamed
+  in place to `copilot.db.adopted-<time>` or `copilot.db.older-<time>`,
+  never deleted. When neither is clearly newer, or a relay may still run
+  on the other, the relay stops with one line naming both and exit code
+  78, which its supervisors, and a systemd unit written by this version's
+  `oar service install`, do not retry. The swap survives a kill. A global
+  install always runs on the state root's data folder, however it is
+  started; a `dataDir` in config.json that an earlier autostart relay used
+  is copied from once and left exactly as it is. A git checkout and a
+  relay on another state root are left alone. A first start that finds an earlier launcher
+  but no database of it says the update may have removed it. A large
+  database takes minutes: the relay logs its size at the start, progress
+  at least once a minute and each step's time at the end, and `oar start`
+  meanwhile says it is still bringing it over. A second `oar start` then
+  no longer removes the relay's lock and starts a second relay.
+- **A relay lock an unclean end left no longer blocks the next start.** A
+  lock from before the last boot, or whose pid now belongs to a process
+  started after it, is stale; a lock still held stops the start with one
+  line naming it and exit code 78. A lock is never seen half written, and
+  one that cannot be read is read again and held unless its time is more
+  than 10 s off (an empty one a power loss left). Two starts recovering
+  the same stale lock no longer both run.
+- **A `TEMP` or `TMP` set with quotes, or naming a missing folder, is fixed
+  for the relay** on Windows (quotes off, else the user's temp folder).
+- **The relay a plain `gh copilot` starts keeps its data outside the
+  package.** After `oar copilot` installed the Copilot CLI extension for
+  every folder, a plain `gh copilot` ran its relay on `server/data` and
+  `server/config.json` inside the installed package, on every platform. A
+  global install's extension now starts it on the OAR state root's
+  config, data and logs, as `oar start` does, and copies a config the
+  package held there once. The database from the package is saved only
+  where the install-time copy ran (see the upgrade note).
+- **Windows autostart waits for a late drive.** Both the sign-in entry and
+  the system-startup launcher now wait up to 5 minutes in all for the
+  `%TEMP%` folder and the drive of the data folder (a RAM disk or a drive a
+  startup script mounts later), where the system-startup launcher waited
+  2 minutes for `%TEMP%` only and the sign-in entry not at all. A wait that
+  runs out writes one line naming what is still missing, then starts the
+  relay anyway: `oar-web-relay-launcher.log` beside the system-startup
+  launcher, `oar-web-relay.log` in the OAR folder (`%APPDATA%\oar`) for the
+  sign-in entry. A data folder on a network share is not waited for. The
+  first start after the update brings a generated entry or launcher up to
+  date without an admin confirmation; edited ones stay as they are. A relay
+  whose data or upload folder cannot be created (its drive still missing, a
+  file in its place) now stops with one line naming the folder and exit
+  code 78 instead of an error trace. A `TEMP`
+  set with quotes (`"D:\My Temp"`) no longer stops the system-startup
+  launcher before it starts the relay.
+- **Cursor conversations keep their agent across updates.** The Cursor
+  worker kept its per-conversation agent stores in
+  `server/data/cursor-agents` inside the installed package, so an update
+  deleted them and a Cursor conversation went on with a new agent that knew
+  nothing of the earlier turns. The stores now live in `cursor-agents` in
+  the relay's data folder (`~/.oar/data` on a global install, unchanged
+  `server/data` in a checkout); `CURSOR_AGENT_STORE_DIR` still overrides
+  it. The copies the state migration made there are read again, as they
+  were at the migration. A conversation with a store in both places uses
+  the one changed last, and one with a store only at the old place keeps
+  using it there; nothing is moved or deleted.
+- **`oar setup --migrate-from` works after the installer has run.** The
+  state migration wrote its marker even when it found nothing to bring
+  over, and every later `--migrate-from <dir>` then did nothing without a
+  word. The marker is now written only after a real copy, and a folder
+  named with `--migrate-from` is always migrated, with a line saying what
+  was copied or why nothing was. It still never overwrites: a `config.json`
+  already in the state root is kept; the empty database the installer's
+  relay created is moved into `backups/` (the relay has to be stopped
+  first, `oar stop`), and a database with conversations makes it refuse
+  with what to do instead.
+  The same folder again only says it is already migrated, and a refused
+  `oar copilot --migrate-from` warns and starts the session anyway. While
+  the migration copies a database it holds the relay's lock, so no relay
+  starts on it in between. Migrated uploads now land in `data/uploads`,
+  where a global install's relay reads them (they went to an `uploads`
+  folder nothing read); uploads an earlier migration left in
+  `~/.oar/uploads` are merged into `data/uploads` at the next relay start
+  (nothing is overwritten or deleted). A migration that fails its check
+  removes only what it copied, no longer the whole state folder, and never
+  a link or file that was there before; a database it moved aside and
+  cannot put back stays in `backups/`. Symlinked folders in the checkout
+  are copied as real folders.
+- **An agent's preview tool reaches only its own conversation's previews.**
+  The tool's `list` showed every live preview of the relay with its token,
+  the only credential of a preview, and `close` closed any of them. `list`
+  now shows the calling conversation's previews, and `close` of another
+  conversation's preview is refused with a message saying so. Copilot and
+  Grok sessions that use the HTTP API are taught the calls with their
+  conversation written in. The relay enforces this for every preview
+  request that names a conversation (the `conversationId` query or the
+  worker's conversation header); the web UI's Settings › Previews and
+  `/preview list` still show and close every preview. Agents present the
+  same relay token as the owner, so an agent that calls the API by hand
+  without naming a conversation still sees them all; see
+  docs/preview-servers.md.
+- **A conversation whose working directory is gone says so.** A Claude turn
+  in a folder that had been deleted or renamed failed with "native binary …
+  exists but failed to launch", blaming the system's libc; a Grok turn said
+  the Grok CLI was not installed, a Copilot (SDK engine) turn showed the
+  spawn's `ENOENT`. Claude, Copilot, Cursor and Grok workers now check the
+  folder before they start their CLI or agent in it, and the turn fails with
+  the folder's path and what to do: restore it, or choose another one with
+  **⋯ → Change CWD**, then send the message again. A worker that cannot be
+  started at all for that reason (a launch without tmux, as on Windows)
+  names the folder in its launch note instead of a missing `node` or
+  `cmd.exe`.
+- **Answering a question no longer gets a long turn requeued by Max turn
+  duration.** Answering one of a turn's questions restarts the max turn
+  duration's clock, but only when the relay picked the turns to requeue; the
+  requeue itself still counted from the turn's start and took every turn
+  past it whenever another turn was due. Such a turn was sent again
+  mid-answer, without the retry limit and without the page hearing of it.
+  The relay now requeues exactly the turns it picked, by the same rule. The
+  settings help and the docs now say where the limit counts from, and that
+  Grok also enforces it itself, counted from the start of the prompt and
+  without pausing for a remote relay approval card.
+- **A resumed sub-agent shows its record and is listed while it runs.** When
+  a Claude session sent a finished background agent a new message, the task
+  panel showed it running, but opening it said "This agent's record could
+  not be loaded", and the session's task list (`read_session`,
+  `list_sessions`) did not list it at all: the relay took it for the
+  agent's first run, which had ended. The resumed agent now
+  opens its own record, which goes on where the first run ended (a note
+  marks where it resumed) and reads running again until it ends; it is a
+  running task of the session again, with a start and an end of its own.
+- **Approval cards take a choice, not typed text, and every one reads it the
+  same way.** OAR's own Allow / Deny cards (agent sessions, watching
+  sessions, write actions in the ask and plan modes) and Claude Cloud's
+  permission cards showed a reply box, and whatever was typed there ("yes",
+  "ok", "allow it") counted as a denial; Claude Cloud even denied a typed
+  "allow". These cards have no reply box now, the relay refuses typed text
+  for any card that does not take it (the card stays open), and a choice
+  counts however it is typed. A card created through the API with choices
+  and no `allowFreeform` is such a card too (the flag defaults to `false`
+  when choices are given). Copilot's permission card keeps its reply box,
+  and now says that a typed reply refuses and tells Copilot why. A card's
+  header (**Agent sessions**, **Relay events**, **Remote relay**, Claude's
+  question headers) is shown above the question, and a question's push
+  notification names the provider that asks instead of always saying
+  "Copilot needs your input".
+- **Reasoning effort reaches every Cursor model that takes one.** Cursor
+  models whose effort parameter is named `reasoning_effort` (Claude Haiku 5.5,
+  Claude Sonnet 5.5, Grok 4.7, Gemini 4 Argon, Gemini 3.8 Flash, Muse Wonder
+  1.0) offered only None in the composer and could not be sent an effort.
+  They now list their tiers once the Cursor models are discovered again
+  (**Refresh** in **Select Models**, or saving the Cursor key), and the
+  chosen effort is sent with the turn.
+
+## [0.9.13] — 2026-10-20
+
+Highlights: a queued relay restart now shows every page what it waits for,
+which messages it holds and which background tasks keep running, and after a
+time you set it asks instead of waiting forever; it never restarts by itself
+while turns run, and can tell the sessions a restart cut off to carry on
+(opt-in). The task console survives a relay restart, marks where a `| tail`
+holds output back, keeps the task's row in view, and counts a test run over
+its whole log. A message
+sent without a model keeps the conversation's model, effort and mode,
+`remote_relay` refuses a model the provider does not list, watching agents
+are no longer woken by every finished shell command, workers reconnect after
+a hung restart, and the unit suite passes on Windows again.
+
+### Upgrade notes
+
+- Migration 0018 (the table `background_task_rows`) runs by itself on the
+  first start. Rows the runtime before this update held in memory are lost
+  one last time at the restart into it. The Node.js requirement is unchanged
+  (22.13 or newer).
+- New settings in **Settings › General**: **Ask after a queued relay restart
+  has waited** (30 minutes by default) and **After a relay restart, tell
+  interrupted sessions to carry on** (off by default); a new push event,
+  **Queued relay restart waited its maximum time** (Settings › Notifications),
+  is on by default.
+- **Watching agents:** a subscription that named no events now leaves out
+  successful shell commands (sub-agent ends and failures still wake it); one
+  that named its events keeps them. Name `task_finished` to get every task end.
+- **Scripts that post `/api/message` without a model** to an existing
+  conversation now get the conversation's own model, effort and mode, or a
+  `409 CONVERSATION_MODEL_UNAVAILABLE` when that model left the catalog,
+  instead of the relay's first model.
+- The npm package guard allows 7.75 MiB unpacked and 520 entries (was 7.5
+  MiB and 510); the restart queue, the stored task rows and the restart note
+  grew the server and the app to about 7.57 MiB and 514 entries.
+
+### Added
+
+- **After a relay restart, tell interrupted sessions to carry on** (Settings
+  › General, off by default, a setting of the relay). A turn a restart cut
+  off for good (the agent had already taken the message, so it cannot run
+  again) used to stop without the agent ever hearing of it. With the setting
+  on, its session gets one compact **relay** note once the relay is back:
+  when the relay restarted, and to check what it was doing and carry on.
+  The user's message is never sent again, and nothing goes to idle sessions,
+  to turns the relay requeues (they run again by themselves), to archived
+  conversations or while a usage-limit pause holds the session; a message
+  queued meanwhile goes first.
+- **The task console marks where a `| tail` holds the output back.** A
+  command piped into `tail` (`npm test 2>&1 | tail -40`) writes nothing
+  until it ends, so its console looked stuck. When the task's command line
+  shows such a pipe (`tail -f` and `head` pass lines on and are left
+  alone), the console marks where the output stops, with a hint to log to a
+  file instead, until more output comes or the task ends; the row's quiet
+  hint says the same on hover. The Claude, Copilot and Grok workers now report a
+  shell task's command line on its row (scrubbed of credentials by the relay
+  and cut at 2,000 characters; `read_session` passes it on).
+- **Load earlier in the console's header.** It sat only above the first
+  line, out of reach while following the end of a long log; the header now
+  has it too whenever there is earlier output.
+
+- **A queued relay restart shows what it waits for, and asks instead of
+  waiting forever.** **🌄 Restart web relay** first lists the sessions with
+  a running turn it would wait for, the messages it would hold, and the
+  sessions with background tasks (commands, monitors, sub-agents), each with
+  whether it keeps running; **Restart when idle** queues the restart,
+  **Restart now** does not wait. While a restart is queued every page shows a
+  banner: *Relay restart queued — waiting for N sessions*, the sessions as
+  links, how long it has waited, that new messages are held until then, the
+  background tasks, and **Restart now** (it asks first and names the
+  sessions it does not wait for) and **Cancel restart**. A new setting,
+  **Ask after a queued relay restart has waited** (Settings › General,
+  30 minutes by default, 5 minutes to 4 hours or no limit), bounds the wait:
+  after it the banner asks *restart now, keep waiting or cancel?* and a push
+  notification (a new event, on by default) asks the same. It never
+  restarts while the turns run, and still restarts as soon as they end;
+  **Keep waiting** waits another period.
+  `POST /api/relay/shutdown` answers with the same picture (`waitingFor`,
+  `held`, `backgroundTasks` with `survives`), so an agent that requests a
+  restart can tell the user, and takes `immediate: true`; `GET
+  /api/relay/shutdown` and `POST /api/relay/shutdown/keep-waiting` are new.
+
+### Changed
+
+- **The open console leaves the task's row in view.** On a screen wider
+  than a phone the console now ends above the task's row in the composer
+  panel, so the row's ✓/✘ chip, clock and **Stop** stay visible and live
+  beside it; on a phone it stays full-screen, with the same chip in its
+  header.
+- **One wording for a task without output.** The row's hover title said
+  "output not available for this provider" and the console "Output is not
+  available for this provider."; both now use the sentence, from the same
+  text the relay answers with.
+- **A watching agent is no longer woken for every shell command that ended
+  well.** A relay event subscription that names no `events` now gets
+  `subagent_finished` instead of `task_finished`: a background sub-agent that
+  finished still wakes the watcher, and so does any task that failed or
+  exited non-zero (`task_failed`), but a shell command that ended well does
+  not. A busy worker ends one every minute or so, and each was a turn of the
+  watcher on its whole context (35 during one 20-minute wait were seen).
+  Name `task_finished` in `events` to get every task end, as before.
+  Existing subscriptions that named no events switch to the new default by
+  themselves; those that named their events keep them. A paired relay on an
+  older OAR applies its own default and refuses `subagent_finished` by name.
+
+### Fixed
+
+- **A message sent without a model keeps the conversation's model and
+  effort.** A message to an existing Copilot conversation that named no model
+  (sent by a script or an agent, not by the composer) ran on the first model
+  of the catalog with effort `none`, which some models refuse, and then saved
+  that model and effort as the conversation's own, so the composer showed
+  them from then on. Such a message now runs on the conversation's model and
+  effort, and saves nothing it did not name. If the conversation's model has
+  left the catalog, the send is refused with a message saying so instead of
+  switching to another model. OpenAI, Claude, Cursor and Grok conversations
+  keep their effort the same way, and so does the follow-up of a plan
+  board's action. A message that names no mode runs in the conversation's
+  mode instead of agent mode, and no longer switches a plan-mode
+  conversation to agent. A message whose turn failed can be sent again at
+  once: it no longer counts as a duplicate of itself.
+- **Test counts of a long run no longer drop out.** The relay counted a
+  test run from the last 64 KB of its output only, so a live run that wrote
+  more lost its runner's first line: the chip disappeared or undercounted.
+  A run still going is now counted over its whole log, read on as it grows
+  (and read again in bounded steps after a relay restart); the closing
+  summary still decides once it is there.
+- **Credentials in background-task rows are blanked.** A task's
+  description, summary and last tool call went to the pages, `read_session`
+  and the stored console rows as the worker sent them, and a Grok terminal's
+  (or a Copilot shell's) description is its command line. The relay now
+  scrubs them like the console output. The scrubber also catches `curl -u
+  name:password` (also attached), `--password`/`--token`/`--secret`
+  values, `mysql -p…`, `docker login -p`, `sshpass -p`, `redis-cli -a`,
+  `aws_secret_access_key` in a file or `aws configure set`, Slack webhook
+  paths, `?key=`/`&sig=`/`&token=` query values and an `Authorization`
+  header in any case and with any scheme word, and leaves a reference such
+  as `$(cat ~/.token)` or `$API_TOKEN` alone.
+- **Inverse text in the task console.** vitest's RUN, PASS and FAIL badges
+  (SGR 7) showed as plain words; inverse text now swaps its colours, so
+  they show filled.
+- **The task console survives a relay restart.** Its rows lived in the
+  relay's memory: after a restart a running command came back to the panel
+  once its worker reported, but the dimmed rows of commands that had
+  finished within the hour were gone, and a console open at the time said
+  the output was no longer available. The rows are now kept in the database
+  (migration 0018): finished rows come back with their ✓ or ✘ for the rest
+  of their hour, and a running command's console reads its output at once.
+  Such a command is shown as running again only when its worker says so
+  (until then its console says it waits for the worker, without **Stop**);
+  one whose worker did not survive the restart is marked finished with an
+  unknown result (a neutral ? instead of ✓ or ✘) after about a minute and a
+  half, its output still readable.
+- **A scroll right after older messages load is no longer undone.** The page
+  put the reader back where they were when the older page arrived, a frame
+  later: scrolling in that frame (up again after the jump-to-bottom button,
+  for instance) was reverted, and could leave you at the end, following new
+  rows you meant to read later.
+- **The jump-to-bottom badge counts a message that arrives just as you scroll
+  up.** One that landed before the page had noted the scroll, a frame and on
+  a busy page up to a tenth of a second, was taken as already seen.
+- **The background-task panel no longer shrinks back for a moment.** While
+  the agent works the page re-reads the conversation, and an answer read
+  before the panel grew put the smaller set of tasks back until the next
+  read. The panel jumped, and a reader following the newest messages could be
+  left above them.
+- **A worker reconnects after a relay restart even when its connect hangs.**
+  A worker's link to the relay was retried only once the socket reported an
+  error or a close. A connect that never finished, a socket the relay
+  accepted but never greeted, or a close that never completed while the
+  relay hung in its shutdown left the worker without a connection and
+  without a next attempt, and messages to its session stayed queued; the
+  relay's replacement of such a worker does not step in while the session
+  is working. The link now gives up a socket that has not completed its
+  handshake within 15 seconds, does not wait for a close after the relay
+  says it is shutting down, and retries a socket that fails to construct.
+  There is always exactly one next attempt, with the usual backoff of up to
+  8 seconds, which now starts over only after a completed handshake. Failed
+  attempts log one line each in the worker log, at most one a minute after
+  the first three.
+- **`remote_relay` refuses a model the provider does not list.**
+  `create_session` passed any model id on, so a Copilot id written with a
+  hyphen ("gpt-5-4" for "gpt-5.4") created a session on another model, which
+  every later `send` with that id failed to reach. A model in
+  `create_session` or `send` is now checked against the list New Chat offers
+  for the provider on the target relay, before any approval card: an unknown
+  one is refused with the close matches and the valid ids ("Unknown model
+  'gpt-5-4' for Copilot on relay …; did you mean 'gpt-5.4'?"), and nothing is created
+  or sent. Claude also takes `opus`, `sonnet` and `haiku` (the newest listed
+  model of that name), and a Copilot id with its effort (`gpt-5.4-high`) runs
+  as that model with that effort. When the relay has no list for the provider yet, the
+  model goes on unchecked and the answer says so. A relay also refuses an
+  unknown Copilot model when another relay's agent starts a session on it.
+- **A preview's websocket is dropped when the browser hangs up before the dev
+  server answers.** A browser that closed its connection with a plain FIN
+  while the upgrade was still waiting on the dev server left both sides
+  open, even when a reset followed: the request
+  to the dev server stayed pending, and the preview lane could not stop
+  until the dev server answered. Both sides are now dropped, and stopping
+  the lane also drops upgrades still waiting on the dev server.
+- **The unit test suite passes and finishes on Windows again.** A preview
+  test waited forever for a websocket hang-up (fixed in the product, above),
+  and several tests expected bare program names or Unix paths where Windows
+  resolves the full path of its own tools; two unlocks recorded in the same
+  millisecond are now listed in the order they were recorded.
+
 ## [0.9.12] — 2026-10-18
 
 Highlights: a background command or monitor in the task panel opens a