@oar-sh/oar 0.9.5 → 0.9.7

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,346 @@ 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
+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,