@oar-sh/oar 0.9.16 → 0.9.18

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

@@ -9,6 +9,14 @@ import { DEFAULT_QUESTION_TIMEOUT_MS } from "../../../../shared/question-timeout
 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";
+import {
+  isOpenAIImageTerminalError,
+  runDirectOpenAIImageTurn,
+  shouldUseDirectOpenAIImageApi,
+} from "../../../../shared/worker-runtime/direct-openai-image.mjs";
+
+// Re-exported for the extension's tests, which import it from here.
+export { shouldUseDirectOpenAIImageApi };
 
 function isImageAttachment(att) {
   const type = String(att?.type || "").toLowerCase();
@@ -257,28 +265,6 @@ export function resolveEmptyFinalTextHandling({ lastStreamedSent = "", lastActiv
   };
 }
 
-export function shouldUseDirectOpenAIImageApi(message = {}) {
-  const providerType = String(message?.providerType || "").trim().toLowerCase();
-  if (providerType !== "openai") return false;
-  const model = String(message?.providerModel || message?.model || "").trim().toLowerCase();
-  return model.startsWith("gpt-image-") || model.startsWith("dall-e-");
-}
-
-function isDirectOpenAIImageTerminalStatus(status) {
-  const numeric = Number(status);
-  if (!Number.isFinite(numeric)) return false;
-  return (
-    numeric === 400
-    || numeric === 401
-    || numeric === 403
-    || numeric === 404
-    || numeric === 409
-    || numeric === 422
-    || numeric === 429
-    || numeric === 503
-  );
-}
-
 export async function publishRelayStreamEvent({
   api,
   message,
@@ -681,71 +667,12 @@ export function createPollingLoop({
     let sendAndWaitStartedAtMs = 0;
     const processDirectOpenAIImageRequest = async () => {
       if (!shouldUseDirectOpenAIImageApi(message)) return false;
-      if (message?.imageOperationId) {
-        const result = await api(
-          "POST",
-          `/api/image-operations/${encodeURIComponent(message.imageOperationId)}/execute`,
-          { messageId: message.id },
-        ).catch((error) => {
-          if (error?.status === 409 || error?.status === 503) {
-            return error?.payload || { outcome: error?.status === 503 ? "retryable" : "terminal" };
-          }
-          throw error;
-        });
-        const outcome = String(result?.outcome || "").trim().toLowerCase();
-        if (!["completed", "executing", "terminal", "uncertain", "retryable"].includes(outcome)) {
-          throw new Error("Image operation returned an invalid outcome");
-        }
-        await session.log(`Image operation ${outcome}`, {
-          ephemeral: true,
-        });
-        return true;
-      }
-      const directModel = String(message?.providerModel || requestedManualModelOrNull(message) || message?.model || "").trim();
-      const prompt = String(message?.text || "").trim();
-      if (!directModel) throw new Error("OpenAI image request is missing model");
-      if (!prompt) throw new Error("OpenAI image request is missing prompt");
-      await api("POST", "/api/activity", {
-        messageId: message.id,
-        conversationId: message.conversationId,
-        mode: message.relayMode || "agent",
-        text: `Calling OpenAI image API directly (${directModel})`,
-      }).catch(() => {});
-      let directResult;
-      try {
-        directResult = await api("POST", "/api/openai/images/generate", {
-          messageId: message.id,
-          conversationId: message.conversationId,
-          model: directModel,
-          prompt,
-          n: message?.n,
-          size: message?.size || message?.contextTier,
-          quality: message?.quality || message?.reasoningEffort,
-          attachments: Array.isArray(message?.attachments) ? message.attachments : [],
-        });
-      } catch (error) {
-        if (isDirectOpenAIImageTerminalStatus(error?.status)) {
-          const terminalError = new Error(
-            `OpenAI image request failed: ${error?.detail || `HTTP ${error?.status || "error"}`}`,
-          );
-          terminalError.code = "RELAY_OPENAI_IMAGE_TERMINAL";
-          throw terminalError;
-        }
-        throw error;
-      }
-      const generatedImages = Array.isArray(directResult?.generatedImages) ? directResult.generatedImages : [];
-      if (!generatedImages.length) {
-        throw new Error("OpenAI image API returned no images");
+      const result = await runDirectOpenAIImageTurn({ api, message });
+      if (result.via === "operation") {
+        await session.log(`Image operation ${result.outcome}`, { ephemeral: true });
+      } else {
+        await session.log(`✅ Sent generated image response (${result.imageCount} image${result.imageCount === 1 ? "" : "s"})`, { ephemeral: true });
       }
-      await api("POST", "/api/response", {
-        messageId: message.id,
-        conversationId: message.conversationId,
-        text: "",
-        generatedImages,
-        model: String(directResult?.model || directModel).trim() || directModel,
-        modelOrigin: isAutoRequestedModel(message?.model) ? "auto" : "manual",
-      });
-      await session.log(`✅ Sent generated image response (${generatedImages.length} image${generatedImages.length === 1 ? "" : "s"})`, { ephemeral: true });
       return true;
     };
 
@@ -988,7 +915,7 @@ export function createPollingLoop({
         }).catch(async () => {
           await api("POST", "/api/requeue", { messageId: message.id }).catch(() => {});
         });
-      } else if (String(e?.code || "").trim() === "RELAY_OPENAI_IMAGE_TERMINAL") {
+      } else if (isOpenAIImageTerminalError(e)) {
         await pushRelayStream(lastStreamedSent, true);
         await api("POST", "/api/response", {
           messageId: message.id,

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

@@ -3,7 +3,7 @@ import {
   formatToolResultActivity as formatSharedToolResultActivity,
   formatVoteMemoryActivity,
 } from "../../../../shared/tool-activity.mjs";
-import { isRemoteRelayToolName } from "../../../../shared/remote-relay-tool-core.mjs";
+import { REMOTE_RELAY_TOOL_NAME, isRemoteRelayToolName } from "../../../../shared/remote-relay-tool-core.mjs";
 import { summarizeRemoteRelayCall } from "../../../../shared/remote-relay-contract.mjs";
 
 export function normalizeActivityText(value, maxToolDetailLength = 140) {
@@ -135,10 +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.
+  // The OAR MCP server's tool reaches the CLI as `oar-relay_tool` (up to
+  // 0.9.17 `oar-remote_relay`): show the same line every other engine writes
+  // for it.
   if (isRemoteRelayToolName(rawName)) {
-    return `Tool (remote_relay): ${summarizeRemoteRelayCall(toolArgsSnapshot(request))}`;
+    return `Tool (${REMOTE_RELAY_TOOL_NAME}): ${summarizeRemoteRelayCall(toolArgsSnapshot(request))}`;
   }
   return detail ? `Tool (${rawName}): ${detail}` : `Tool (${rawName})`;
 }

package/CHANGELOG.md

@@ -3,6 +3,418 @@
 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.18] — 2026-10-26
+
+Highlights: Claude chats can run on a Claude Console API key. Claude API is
+a provider beside your subscription, with an optional monthly spend cap and
+a card in Check Usage with the estimated spend. A Claude chat can switch
+between the subscription and the key and keep its Claude Code session, also
+when it is paused at the usage limit. The relay's agent tool is now called
+`relay_tool`. DeepSeek and Claude API chats start with all hooks off, and a
+subscription chat no longer runs on an API key that Claude Code's settings
+hand it.
+
+### Added
+
+- **Claude API: Claude chats on a Claude Console API key.** A provider
+  beside Claude (your subscription), billed to the Console organisation
+  the key belongs to.
+  - Settings → Providers → Claude API holds the key, the switch, the
+    default model and an optional monthly spend cap in US dollars. The key
+    is stored on the relay host and never shown again: the tab only says
+    that one is saved. Any `sk-ant-` Console key is taken; Claude login
+    and session tokens and Admin keys are refused when you save. A key
+    Anthropic itself refuses stays saved, and the tab's status line says
+    so until a save or Refresh models goes through. A cap the field cannot
+    take is named under the field.
+  - The relay lists the key's models from Anthropic when the key is saved,
+    when Claude API is switched on again, and on Refresh models. Until
+    then it offers the Claude tab's models.
+  - Commit attribution, the background command limit, the effort levels
+    and the compaction window stay on the Claude tab, shared by both; the
+    Claude API tab links there.
+  - New Chat offers Claude API, Select Models has a Claude API tab, and
+    its chats show a gold "Claude API" pill and "🔒 Session locked to
+    Claude API models."
+  - A turn that Claude API refuses or could not run ends with buttons:
+    Claude API settings (at the cap field when the monthly cap is
+    reached), Switch to subscription, Add funds, Console billing or
+    Console limits, as fits the reason.
+  - When the relay refuses to start a Claude API chat (the monthly cap, no
+    key, switched off), New Chat stays open with the reason, Claude API
+    settings, and Start on subscription, which starts the same chat on
+    the Claude provider; on a phone the dialog scrolls to it.
+- **Switch a Claude chat between your subscription and the Claude API
+  key.** `POST /api/conversation/:id/billing` moves a chat between
+  `claude` (the subscription) and `claude-api` (the saved key). It keeps
+  its Claude Code session.
+  - In the browser, a Claude chat has a `Subscription | API key` toggle
+    under the lock note while Claude API is on with a saved key. It says
+    what a pending switch waits for, and why a side cannot be chosen; at
+    the monthly cap it says the chat stays on the subscription, and so
+    does the usage-limit banner.
+  - The switch applies from the next turn: a running turn finishes on the
+    billing it started on. Messages already queued run on the new one.
+  - The relay restarts the chat's Claude Code between turns. It waits
+    while a turn, a question, a compaction or a background task is still
+    running.
+  - The transcript notes each switch. The first turn on the key has no
+    prompt cache and costs more.
+  - The switch is refused, with the reason, when the key is missing or
+    Claude API is off, when the monthly cap is reached, or when the
+    chat's model is not on the target's model list.
+- **Switch this chat to API key at the usage limit.** When a subscription
+  chat is paused at the Claude usage limit, the banner offers the switch
+  if the chat may move to the key. The paused turn then carries on on
+  the key at once. Nothing switches by itself.
+- **Agents can switch a Claude session's billing.** `relay_tool` `send`
+  takes `provider` (`claude` or `claude-api`) for a Claude session. The
+  other billing switches the session together with the message:
+  - in one call, so a refused switch sends nothing and a refused message
+    switches nothing;
+  - the approval card says "Switches billing to API key";
+  - a relay from before this version refuses it and sends nothing.
+- **A Claude API card in Check Usage.** It shows what this relay's turns
+  on the Claude API key are estimated to have cost today and this month,
+  per model, with the tokens, and the monthly cap as a bar when one is set.
+  - The figures are Claude Code's own estimate from its price table, so
+    sub-agents, compaction and web search are in them. The Console's
+    billing page (linked) has the real figures and the balance.
+  - Days and the month follow the relay's time zone, and the cap starts
+    over at local midnight on the 1st.
+  - Tokens Claude Code has no price for show as "no price known" or
+    "estimate incomplete", never as $0.
+  - Turns paid from a Max or Team plan's subscriber API credit are counted
+    too; OAR cannot see that credit.
+  - The card stays while a key is saved, also with Claude API switched
+    off, so the month's spend stays in view (DeepSeek's card goes with the
+    provider).
+- **A monthly cap for Claude API.** Once this month's estimate reaches the
+  cap set in Settings → Providers → Claude API:
+  - a new turn on the key does not run: the chat gets a note with the code
+    `relay.claude-api-cap-reached`. A turn Claude Code starts by itself,
+    when a background task reports back, gets the note and that chat's
+    background tasks are stopped as soon as the relay hears of the turn,
+    since each report would start another such turn; the turn itself is
+    stopped when the worker takes the stop. Its first request may already
+    be billed, and a short turn can end before the stop arrives. The note
+    also mentions tasks no stop reaches, since they can keep starting such
+    turns and keep a switch to the subscription waiting. The note comes
+    once per chat until the cap clears, a Claude API setting is saved, or a
+    turn of that chat runs on the key again. The same stop applies when
+    Claude API has no key or is switched off;
+  - a switch to the key is refused;
+  - an agent's send to a session on the key and a new Claude API chat (New
+    Chat or an agent's `create_session`) get 409 `CLAUDE_API_CAP_REACHED`,
+    and nothing is queued or created.
+
+  A turn that is already running finishes. A turn's cost is booked when it
+  ends, so running turns can take the month past the cap. The cap counts
+  only the priced part of the estimate. If the spend cannot be read, the cap counts as
+  reached. Console spend limits still apply on top.
+
+### Changed
+
+- **A send does not switch a Claude chat's billing.** A message that
+  names the other billing gets 409 `CLAUDE_BILLING_SWITCH_REQUIRED`
+  (before, a Claude API chat ignored `provider: "claude"`). A message
+  from a page that still showed the other billing gets 409
+  `CLAUDE_BILLING_CHANGED`. Its text goes into the chat's draft, so the
+  page, and a send replayed from the offline outbox, lose nothing. The
+  outbox keeps the text only, not attachments.
+
+- **No hooks or status line run in DeepSeek chats.** In 0.9.17, Claude Code
+  in a DeepSeek chat ran the hooks and the `statusLine` command of
+  DeepSeek's settings folder, of the chat folder's `.claude/settings.json`
+  and `settings.local.json`, and of plugins, as the relay's user with the
+  DeepSeek key in their environment; a folder's `SessionStart` hook ran
+  before the relay had pinned the endpoint and key. Now those chats start
+  with all hooks off, and so do Claude API chats. The setting is on Claude
+  Code's command line, so it is in force from the start, and a folder's
+  settings can't turn it back on (`scripts/claude-cli-hooks-proof.mjs`
+  shows it on the bundled Claude Code). Hooks in managed settings still
+  run. Chats on your Claude login keep their hooks and status line. The
+  agent's own commands can still read the key; the relay redacts it in
+  what it shows.
+- **The relay's agent tool is now called `relay_tool`.** It was
+  `remote_relay`, and it is listed under the new name on every provider
+  (Claude's `mcp__relay__relay_tool`), with the same actions and fields; the
+  docs and the agents' instructions use it too. OAR's own MCP server, which
+  Grok and the Copilot extension engine use, still runs a call to
+  `remote_relay` but no longer lists it. Tool lines written under the old
+  name still show as this tool.
+  - If your own instructions, permission rules or hooks name `remote_relay`
+    or `mcp__relay__remote_relay`, change them to `relay_tool` or
+    `mcp__relay__relay_tool`: outside OAR's MCP server the old name is
+    refused.
+- **A subscription chat never runs on an API key.** Claude Code takes an
+  API key over your Claude login when one of its settings hands it one:
+  - `env.ANTHROPIC_API_KEY` in `~/.claude/settings.json` or the chat
+    folder's `.claude/settings*.json`;
+  - an `apiKeyHelper`;
+  - a Console login.
+
+  Until now such a chat ran on that key and billed the key's owner. Now
+  the turn stops at Claude Code's start, with a note naming the source
+  and the setting to remove. At most one model request, sent a moment
+  after that start, can go out first.
+
+- **The docs cover Claude API.** The providers guide has a Claude API
+  section: the key, the models, the shared `~/.claude`, the billing switch
+  and when it applies, what fails closed, the monthly cap and the
+  subscriber API credit. The web UI, configuration, security,
+  agents-together and troubleshooting pages, the README, the server
+  README and DEVELOPING.md (the worker and its live check) cover it too,
+  and the feature tracker has a Claude API page. Troubleshooting has two
+  known gaps:
+  - a key that is not tied to a workspace gets HTTP 400 from Anthropic;
+    for now, create the key inside a workspace (naming the workspace in
+    OAR is planned);
+  - a model Claude Code has no price for (currently Claude Haiku 5.5)
+    shows "no price known" on the Claude API card, and its tokens are left
+    out of the estimate.
+- **Corrections to the 0.9.17 notes:**
+  - DeepSeek's budget bar changes colour at 50 % and 75 % of the budget
+    and turns red at 90 %; the notes said amber near it and red over it.
+  - The composer's context chip shows DeepSeek's 1M window (1,048,576
+    tokens) as `1.05M`.
+  - The `preview` tool's hint to bind a dev server to 127.0.0.1 reaches
+    only sessions that have the tool (Claude, Claude API, DeepSeek, Cursor,
+    and Grok and Copilot's Extension engine through OAR's MCP server), not
+    every provider. Copilot's SDK engine, and those two when the relay runs
+    with `OAR_MCP_SERVER=0`, are taught the preview API without it.
+
+### Upgrade notes
+
+- **Downgrading to 0.9.17:** first switch Claude chats on the Claude API
+  key back to Subscription. 0.9.17 does not know Claude API, so a chat
+  left on the key runs as a Copilot chat there. That now includes a chat
+  that started on the subscription and was switched to the key. 0.9.17
+  ignores the new database columns and tables. The two triggers on the
+  queue table keep stamping its new column there, which does no harm.
+- **Downgrading to 0.9.17 turns hooks back on in DeepSeek chats:** they
+  run the hooks and status line of their settings folders again.
+
+## [0.9.17] — 2026-10-25
+
+Highlights: DeepSeek is a provider of its own. Paste a DeepSeek API key and
+New Chat offers DeepSeek's models, with all four modes, tools, question
+cards, sub-agents and reasoning effort, the 1M context window, a usage card
+with the balance and the estimated spend, and an import of earlier usage
+from DeepSeek's usage export. A new session in a group now shows
+at the top of the group. And the relay's own Anthropic credentials
+(`ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`) no longer reach the agents it
+starts.
+
+### Added
+
+- **DeepSeek is a provider of its own.** Paste a DeepSeek API key in
+  Settings → Providers → DeepSeek, and New Chat offers DeepSeek with the
+  models DeepSeek lists (`deepseek-flash` by default, `deepseek-v4-pro`).
+  - A DeepSeek chat runs Claude Code on the relay host against DeepSeek's
+    Anthropic-compatible API, so it has all four modes, tools, question
+    cards, sub-agents, steering, Stop and background tasks.
+  - Reasoning effort is low, high or max (high by default). The model can
+    change between turns; a switch to a model without image input is
+    refused once the chat holds images.
+  - The context panel shows the 1M window, and the chat compacts at 400K
+    unless you set another window there.
+  - Commits carry `Open Agent Relay (DeepSeek Flash)` or no attribution, as
+    set on the DeepSeek tab.
+  - The key is stored on the relay host, is never sent to browsers, and
+    reaches only DeepSeek's workers. Their Claude Code keeps its state in a
+    directory of its own, without your Claude login. The tab's Advanced
+    section takes another base URL (https, or http on the same machine).
+  - The chat folder's settings can't route the key elsewhere. A
+    `.claude/settings.json` or `.claude/settings.local.json` there that sets
+    `ANTHROPIC_BASE_URL`, a key of its own or an `apiKeyHelper` took the
+    DeepSeek key to that endpoint, or replaced it; the relay now pins
+    DeepSeek's endpoint and key over the folder's settings, and with them
+    the proxy, TLS trust, provider and credential settings, without putting
+    the key on the command line, and sends nothing when Claude Code doesn't
+    take them within a minute (`scripts/deepseek-cli-proof.mjs` shows it on
+    the bundled Claude Code). This covers settings, not commands: hooks and
+    a status line in those files still run as the relay's user, as in any
+    Claude Code chat, so use DeepSeek chats only in folders you trust.
+  - The agent's own commands can read the key from their environment, as
+    with any key a CLI holds. The relay replaces it with `[redacted]` in
+    everything a worker posts (replies, thoughts, tool activity, sub-agent
+    text, questions, task output), including the first part of a key cut
+    short at a text's end or before an ellipsis, the last part of one a
+    text starts with, and keys changed since the relay started, before it
+    stores or shows it; the DeepSeek worker does the same in its log. Task
+    output the relay reads from a task's file is scrubbed by shape only
+    (`sk-` keys and other long tokens), not by the saved key's exact text.
+    This keeps the key out of what the relay stores and shows; it is no
+    barrier against the agent, which can change the text, call the relay's
+    local API without the worker header or read the relay's database.
+  - The usage view has a DeepSeek card: the account balance, read with the
+    saved key, and the estimated spend of DeepSeek turns on this relay, by
+    model, from DeepSeek's published prices with peak and off-peak hours
+    (the card names the peak hours in your browser's time zone). On Chinese
+    public holidays DeepSeek charges off-peak prices all day; the estimate
+    doesn't know those dates, so turns at peak hours on a holiday are
+    counted at double the real price. Only WebSearch runs on DeepSeek's
+    servers: its searches are counted at $0.75 / ¥5 per 1,000 requests from
+    2026-10-31 16:00 UTC, on a "Search" row of their own, taken from Claude
+    Code's own totals, which count the request its WebSearch tool makes.
+    WebFetch reads the page on the relay host and costs only tokens, and
+    DeepSeek does not bill count_tokens requests.
+  - The card draws the money: a balance bar per currency, measured against
+    the balance after its last top-up (kept on the relay; migration 0029
+    notes when it rose), or against a starting balance set on the DeepSeek
+    tab, such as the first top-up, until the next top-up replaces it (typed
+    in again, the same amount too, it counts from then on); the
+    daily spend of the last 30 days as columns stacked by model, with the
+    day's total on hover or tap; where the money goes per model (cache hits, misses,
+    output, searches) with what the cache saved; and a monthly
+    budget bar when a budget is set on the DeepSeek tab, in the currency
+    chosen with it (USD or CNY, named on the bar; a budget saved without one
+    follows the balance's currency), amber near it and red over it, starting
+    over on the 1st (UTC). No chart library; every bar has a text equivalent
+    and every chart a table, in both themes. The card shows everything at
+    once, figures first (the balance and the spend as label-and-value rows,
+    the tables by model open, the note on the estimate last), and fits a
+    phone's width.
+  - A DeepSeek chat's cold start reads "Starting Claude Code for DeepSeek",
+    and the `preview` tool tells the agent to bind its dev server to
+    127.0.0.1 (every provider).
+  - Sub-agents stay on the chat's model. Claude Code's model aliases are
+    pinned to it, so a sub-agent the agent asks for as "opus" or "sonnet",
+    or one without a model, runs on the chat's model, and one asked for as
+    "haiku" on DeepSeek Flash; before, an alias went to DeepSeek as a Claude
+    model id, which DeepSeek serves by its own mapping (a Flash chat got a
+    V4 Pro sub-agent). A model switch between turns now restarts the chat's
+    Claude Code, like an effort change. A sub-agent's badge names the
+    DeepSeek model, and usage a Claude Code still reports under a Claude
+    name is booked and priced under the DeepSeek model that served it;
+    rows booked under a Claude name earlier are folded in at start-up
+    (migration 0026). The folded rows are priced at one time each, the
+    row's last turn, so a row that spans peak and off-peak turns is
+    approximated (the token part by up to 2×).
+  - **Import usage export** on the DeepSeek tab takes the two CSV files
+    DeepSeek's usage page exports (amount and cost) and shows what was
+    imported. The usage card then shows DeepSeek's own figures for the saved
+    key on the days the export covers, by the export's days, and the
+    estimate on the other days; the card says through when. Only rows in
+    the card's currency are used, and the import says when they won't be.
+    A re-import replaces the key's days it covers, a day with a period that
+    has not ended is left out, and so are export days up to and including
+    the first day of the relay's daily history.
+    `npm run deepseek:import -- amount.csv cost.csv [db-path]` does the same
+    from the shell. The relay's own usage logging is unchanged (migration
+    0030 adds a table of its own).
+
+### Changed
+
+- **A new session in a group shows at the top of the group.** In a group
+  you ordered by hand, a session an agent creates there, one started with
+  the group chosen, or one moved in by its menu used to join at the end;
+  it now comes first, right under the group's first session. The order you
+  set stays, and the next drag numbers the members again from there.
+- **A host's `ANTHROPIC_API_KEY` and `ANTHROPIC_AUTH_TOKEN` no longer reach
+  any worker.** A relay started with either in its environment handed it to
+  every worker it started (Copilot, OpenAI, Cursor, Grok, Claude, Claude
+  Cloud, DeepSeek), on every platform, and Claude Code prefers either to the
+  Claude login. Now no worker gets them, and under tmux the worker's shell
+  also unsets them, so they cannot come back from a tmux server that was
+  already running or from your login profile. Claude chats that ran on such
+  a key now run on the host's Claude login.
+
+### Fixed
+
+- **The Inbox opens at the top, or where you left it.** It used to open at
+  the scroll height of the transcript it replaced, somewhere in the middle of
+  the list. It now opens at the top the first time and afterwards where it
+  was scrolled when you last left it.
+- **The session header on a phone comes in two rows.** ☰, the title and the
+  buttons share the first row, so the title gets the width left after the
+  buttons. The "via agent" line, the watching, watched and scheduled chips
+  and the folder sit side by side on a second row across the header, and a
+  chip no longer breaks inside its text. The desktop header is unchanged.
+- **A DeepSeek chat's failures carry DeepSeek's codes, and their buttons
+  show.** A refused DeepSeek request printed as `relay.claude-api-error`,
+  and a used-up balance or a refused key as `relay.claude-deepseek-balance`
+  or `relay.claude-deepseek-api-key`, which the **Top up DeepSeek** and
+  **DeepSeek settings** buttons never matched. They now print as
+  `relay.deepseek-balance`, `relay.deepseek-api-key`,
+  `relay.deepseek-api-error` and so on, without the Claude account advice.
+- **A relay's Claude login token no longer reaches workers that are not
+  Claude's.** On a relay started with `CLAUDE_CODE_OAUTH_TOKEN` in its
+  environment, the Copilot, OpenAI, Cursor and Grok workers got the token too:
+  on Windows and without tmux through the environment they inherit, and under
+  tmux whenever the launch started the tmux server, which then kept it for
+  every later session. Now only Claude Cloud and Claude workers get it, under
+  tmux through the owner-only file. Local Claude chats on a host that runs on
+  the token alone now get it under tmux as well.
+- **A relay started from inside a Claude Code session no longer hands that
+  session to its workers.** Its variables (`CLAUDECODE`, the session id, the
+  messaging socket and token, entrypoint, `CLAUDE_PID`, `CLAUDE_EFFORT`)
+  reached every worker, with and without tmux, and a DeepSeek chat's Claude
+  Code took itself for a child of the host's session. The launcher now drops
+  them for every provider, and the DeepSeek backend drops them again. The
+  values of one launch (worker kind, model, folder) go into that session's
+  command only, no longer into the environment a tmux server started by the
+  relay kept for every later session. Under tmux that was not enough: a new
+  tmux session starts from the tmux server's own environment, which a
+  server started from inside a Claude Code session, or by an older relay,
+  carried on to every worker. Every worker's command now begins by unsetting
+  the host session's variables and the launch variables it sets no value
+  for, so a stale model or worker kind from an earlier launch is gone too.
+  The host session's variables are matched by family as well as by name
+  (every `CLAUDE_CODE_SESSION_*`, `CLAUDE_CODE_*_SESSION_ID` and
+  `CLAUDE_CODE_MESSAGING_*`, with the SDK host's version and app markers
+  and the Bash cap a relay's Claude worker gives its CLI), so a name a
+  newer Claude Code adds is dropped too; your own `CLAUDE_CODE_*` and
+  `CLAUDE_AGENT_SDK_*` settings stay. A DeepSeek chat's Claude Code also no
+  longer gets the relay's settings for its worker (worker kind, the relay's
+  folders and tools file, `COPILOT_ALLOW_ALL`, `SESSION_ID`);
+  with them the worker log file a relay started from inside a worker
+  session inherited, and, by name, every secret the launch carries no value
+  for (other kinds' and its own alike) that a shell may have exported into
+  the tmux server's environment; the worker's own keys come from its secret
+  file, read after that.
+- **The DeepSeek spend no longer undercounts a Claude Code that started
+  counting over, and no longer double-counts a report that fell behind.**
+  The relay books what a worker's report adds to the session's last totals;
+  totals below them were booked as nothing. Now the worker names its Claude
+  Code process in each report (`runId`; migration 0027 keeps it with the
+  checkpoint): totals below the checkpoint from the same process are a
+  stale report (a retried post, or one delivered after a later one) and
+  book nothing, while from another process they are a CLI counting from
+  zero again on the same session id, booked in full. The web searches and
+  fetches are reported as the process's running counts and booked the same
+  way, so a retried post no longer counts them twice.
+- **The DeepSeek spend no longer books a session's history again after a
+  Claude Code died hard.** Claude Code writes its cost state at exit, so a
+  resumed CLI that was killed left an older snapshot, and the next resume
+  restored totals below what the relay had booked: read as a process
+  counting from zero, the whole restored history was booked once more. The
+  worker no longer reports what the CLI restored: it reports each process's
+  own totals, counted from zero (what the session totals grow by per
+  result; for the first result of a resumed process the turn's own usage,
+  which leaves out what sub-agents spent in that one turn), and the relay
+  books a new process in full and the increase within one. The search and
+  fetch counts keep a run id of their own in the checkpoint (migration
+  0028), so a report with counts only no longer moves the token totals' run
+  id, and a `/clear` in the CLI, which starts a new session id, starts the
+  worker's counts over with it instead of booking the old session's under
+  the new one. A turn that finishes after its Claude Code died (a background
+  task's continuation whose row was still registering) reports under that
+  process, not under the one running by then or as a report from no
+  process, and a result that arrives behind a newer one never lowers the
+  worker's baseline. A late report of an earlier process after a later one
+  started is booked in full, and the later process's next report is booked
+  in full too: the relay cannot tell either from a new process.
+- **OpenAI image models work on the SDK engine again.** A turn on
+  `gpt-image-*` or `dall-e-*` went to the Copilot runtime as a chat turn
+  and failed ("No available capacity was found for the model", or a request
+  rejected as invalid). It now goes to the OpenAI Images API, as on the
+  Extension engine, and an attached image is edited. A refused image request
+  now fails its turn with `relay.image-provider-rejected` instead of staying
+  in progress until the relay ran it again, and an OpenAI chat turn that
+  fails on the SDK engine says OpenAI rather than Copilot.
+
 ## [0.9.16] — 2026-10-24
 
 Highlights: agents can file the sessions they start into your session