samagotchi 0.63.0 → 0.65.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20b05cd0da6dfdd621eba3b2add37f00b2abe96c2e3950d8ddd066bdf3078424
-  data.tar.gz: ecf5784f9f82c8a8c9e813185570d326a3f4d9ad3a404033f53abf1b62a20902
+  metadata.gz: 43045b7872d6b50ba24cc2ef1678ac6708346aac9236a5764593660e4e81fc6f
+  data.tar.gz: dad96a9922329ea3294d7bf04159b3c829796bdfda03d42eef724bbee4a3e4e7
 SHA512:
-  metadata.gz: 302c8ccf54cc947c9165fe8e30f4d32b4054ee02a1e2d62cbb7d7942a30574af58af84a7eafc5b2daf24a8f167e98024e2798fcacccf597b919435019d498613
-  data.tar.gz: b6ac96ff05fb4e52a5705b55de3fa505054860b154cd6622c4badc232c6284bc5e80d57ffc94b13a7eae1384557acd5b697b630a0ed21be1a8e85d99610b3d04
+  metadata.gz: 4a35a44e9905f8c3411a656383c8a7f2493318732b959d526cdcbdc5dba90e71e874fe678057d3b060878dc5e4560398683790dade299258bd43cf541e0b62cf
+  data.tar.gz: 9dc56d9cd85b5c5f323315f99bc7c2f4e7580927966f41723a833db561dd5d6c0b3a8720c92ea32e1fafbb3b75e9eb0e93e57e9c4784e1a9983f95e7ac6f17c6

data/CHANGELOG.md

@@ -8,6 +8,89 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.65.0] - 2026-10-13
+
+### Added
+
+- **Anthropic Messages hosts** (`api: anthropic`): streamed text and thinking, native tool use, images, usage with
+  cache reads and writes, thinking blocks replayed verbatim (also after `--resume`; `reasoning_history` defaults to
+  `all` there). A new host key `auth: bearer|x-api-key` (any host) picks the header the key goes in. Thinking levels
+  map to Messages' thinking (`off` disabled, `low`/`medium`/`high` adaptive at that effort, `default` nothing), with
+  fallbacks when a host refuses a field. Recaps, `ctx.ask_model` and broadcast triage work there too. See
+  docs/configuration.md, "Anthropic Messages hosts". **Known limit until the next release:** Claude 5.x models
+  (Opus, Sonnet and Haiku 5.5, Fable 5.1) may stop a turn with a 400 "… bound to a different conversation" after the
+  history changed under their thinking blocks; the next release adds the recovery.
+- `dialect: fireworks` on an `api: anthropic` host, for Fireworks directly or behind a gateway: Bearer auth, no
+  thinking `display`, no `cache_control`, and `x-session-affinity` for cache routing. `chi self` names it.
+- A provider's refusal (Messages `stop_reason: refusal`, or an empty `content_filter` stop) ends the turn with
+  `no answer: refused by the provider (category)` in every UI and isn't retried. A `content_filter` stop after some
+  text keeps the text, marked `[cut off by the provider's content filter]`.
+- Web composer: a row above the text field shows the keys while idle and, while a turn runs, where a message sent now
+  goes in (after this thinking step, tool call or answer, with its clock), with `cut in now` and `queue for after the
+  turn` links. Alt+Enter (Option+Enter) queues. See docs/cli.md, "Typing during a turn".
+- Terminal: while a turn runs, the status row ends in `· typing goes in at the next step (/cut, /queue)`.
+
+### Changed
+
+- Web: a message queued for after the running turn sits below the running turn's card, not among its rows, also
+  after a reload.
+- A chat host that refuses a sampling field (`temperature`, `top_p`, `top_k`) gets the step again without it instead
+  of the turn failing; on `api: openai` hosts such a 400 no longer turns reasoning off.
+- A Splash or Fireworks model's vision comes from its model list instead of reading "unknown".
+
+### Fixed
+
+- A server error without a numeric code is classified by its type: an invalid request fails at once instead of being
+  retried, an unknown model (404, `NOT_FOUND`) is no longer retried, a `timeout_error` is a 504.
+- Anthropic's context-overflow 400s ("prompt is too long", "input length and `max_tokens` exceed context limit")
+  roll the turn back and report it as too long for the context window, also through a gateway on the OpenAI path.
+
+Update with `chi update` (the system bundle moves with the gem).
+
+## [0.64.0] - 2026-10-13
+
+### Added
+
+- `/queue TEXT` during a running turn now works in an attached terminal and the web composer too, as it did in the
+  plain REPL: TEXT runs as a turn of its own after the running one, instead of merging into it (`(queued: runs after
+  this turn)`). A session whose worker is older than this says to restart it rather than steering the turn. See
+  docs/cli.md, "Typing during a turn".
+- `chi send --queue`: the message runs as a turn of its own after the running turn instead of merging into it, and
+  `chi send --queue --wait` waits for that turn's own answer (a running turn no longer refuses it; the running turn's
+  reply, end and questions are not the answer). Each turn's reply file now carries its message's id. See
+  docs/sessions.md, "Sending a message", and docs/sub-agent.md.
+- Plugins: `ctx.sessions.send(id, text, delivery: :queue)` runs the message as a turn of its own after the session's
+  running turn; `delivery: :cut` raises (plugins never cut). See docs/plugins.md.
+
+### Changed
+
+- Plain REPL (`--no-shared`): the lines a turn left over (a steer it didn't merge, `/queue` lines, image lines, commands
+  that wait) run in the order you sent them; before, an unmerged steer ran ahead of a `/queue` line typed earlier.
+- A message with images sent during a running turn no longer holds back the text lines sent after it: they go in at
+  the turn's next step as usual, and the image message still runs as a turn of its own after it.
+
+### Fixed
+
+- Stopping a session mid-turn (`chi sessions stop`, the web's stop, a parent stopping its delegate) cancels the turn
+  with its own reason, `session_stopped`, instead of the user's Stop: the turn's line reads "canceled (session
+  stopped)", a command it was running "stopped as the session was stopped" (slow-commands 0.2.2 counts it as
+  stopped, not slow), and `chi send --wait --format json` reports `cancel_reason: session_stopped`.
+- A delegate (and any worker a session's own commands start, such as `chi send --new`) reads `hosts:` from config.yml
+  as it starts, so it sees a host added or changed after its parent's worker started; before, it got the parent's
+  start-time hosts through `SAMAGOTCHI_HOSTS_JSON`, which workers no longer inherit (one set in your shell
+  applies to that chi process only; put hosts in config.yml).
+- Web: a step that only called plugin tools with a verb label is titled by the label ("echoing"), not "working
+  with echoing"; among other tools such a call is named by its tool ("working with read, echo").
+- Web: a send from a stale tab into a session deleted meanwhile goes back to the start page with a "was not
+  found" notice, the line kept in the composer, instead of an alert.
+- `chi send`, the web composer and a plugin's `ctx.sessions.send` now report a message the session's worker refuses
+  (a 4xx answer such as a delivery it doesn't run) instead of writing it as an input file the worker would merge
+  anyway; a body over the worker's size limit still goes in as a file, as before.
+- `chi answer`, `chi send --wait ID` (no message) and `delegate_result` wait for the reply of the turn they are about
+  (the answered turn, the running turn, the follow-up's turn), not a newer one queued behind it; a Continue of the
+  step-limit question gets the continued turn's reply, and a Stop ends the wait as `not_continued`. Workers older
+  than this keep the old behaviour.
+
 ## [0.63.0] - 2026-10-13
 
 ### Added
@@ -2750,7 +2833,9 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.63.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.65.0...HEAD
+[0.65.0]: https://github.com/dm1try/samagotchi/compare/v0.64.0...v0.65.0
+[0.64.0]: https://github.com/dm1try/samagotchi/compare/v0.63.0...v0.64.0
 [0.63.0]: https://github.com/dm1try/samagotchi/compare/v0.62.0...v0.63.0
 [0.62.0]: https://github.com/dm1try/samagotchi/compare/v0.61.0...v0.62.0
 [0.61.0]: https://github.com/dm1try/samagotchi/compare/v0.60.0...v0.61.0

data/docs/architecture.md

@@ -73,6 +73,12 @@ TerminalUI  ──  delegates  ──▶  Engine
   delegates all core work to an `Engine`.
 - The `on_event:` seam on `run_turn` exposes raw `KernelLoop` events plus the
   higher-level turn events, so any new UI can render without terminal coupling.
+- **`ComposerRoute`** (`lib/samagotchi/composer_route.rb`) decides where a line typed at
+  either terminal's prompt goes (the REPL's `steer_line` / `run_input_line`, the attached
+  `AttachedLoop#submit`): `/cut TEXT` / `/queue TEXT`, a terminal's own word, a session
+  command, a typo, a prompt. Each UI keeps what it does with the route. The web's
+  `composer.js#routeComposerLine` decides the same; `spec/fixtures/composer_routes.json`
+  holds the cases both answer (see [testing.md](testing.md)).
 
 ## Request / turn flow
 
@@ -94,7 +100,7 @@ terminal renders the events it gets over the Bridge.
 | Core | `Samagotchi::Engine` | System prompt, memory injection, tool declarations, session lifecycle, model↔tool loop (`run_turn`). No terminal coupling. |
 | UI | `Samagotchi::TerminalUI` | REPL (Reline), rendering, REPL commands. Delegates all core work to an `Engine`. |
 | Model loops | `KernelLoop` (via `LLM::NativeBackend`), `LLM::ChatLoop` | The model↔tool loop: raw prompt or OpenAI chat API, chosen per host (see below). |
-| Adapters | `Samagotchi::Client`, `LLM::OpenAIChat`, `LLM::HTTP` | Raw-prompt servers, the OpenAI chat API, and the HTTP both share. |
+| Adapters | `Samagotchi::Client`, `LLM::OpenAIChat`, `LLM::AnthropicMessages`, `LLM::HTTP` | Raw-prompt servers, the OpenAI chat API, Anthropic's Messages API, and the HTTP they share. |
 | Tools | `lib/samagotchi/tools/*` | Execute, read, edit, write, memory, task_*, web_fetch, delegate/delegate_result, ask_user_question, reminders, send_note, list_sessions, context_read, forget_outputs, plus runtime/output-guardrails. |
 | Bundles | `lib/samagotchi/memory_bundle/*`, `BundleCommand` | `chi bundle`: install/upgrade (3-way merge), build, uninstall; the install record under `.bundles/<name>/` that the hook, guardrail and plugin loaders read ([internals/bundles.md](internals/bundles.md)). |
 | Background | `Samagotchi::Worker`, `Samagotchi::SessionManager` | `SessionManager` forks/spawns one worker process per session; its `Worker` builds the `Engine` and `Bridge` (no terminal rendering) and runs queued turns. The spawned process (own process group) forks the worker, which `setsid`s and is reparented to init once its starter exits (it waits until the worker holds `owner.lock`, so the spawner's `Process.detach` waiter tells a starting worker): nothing that walks the spawner's process tree reaches it (`SAMAGOTCHI_WORKER_DETACH=1`, `detach_from_spawner`). The lock's pid is the worker's; `spawn`'s `child_pid` is its starter's. |
@@ -369,7 +375,11 @@ session every 10 s, so a `kill -9` shows within a second. The summary (`Web::Ses
 shared with `/api/sessions` and the session view) carries `owner`, `project_root` and
 `bridge_up` (the sidecar is there *and* the lock is held: the page attaches its stream on it), and
 from that sidecar `worker_version` (the chi the worker runs) and `worker_features`
-(`Bridge::FEATURES`, what a client may ask of it beyond the routes). A worker's Bridge snapshot
+(`Bridge::FEATURES`, what a client may ask of it beyond the routes: `restart`, `task_stop`, `reparent`,
+`delivery`, a worker that queues a message for after the turn; `SessionManager.deliver_turn` and
+the attached TUI refuse a queue to a worker without it, which would steer; `turn_ids`, a worker whose running
+turn's mark, continue turn and Stop carry the turn's `enqueued_id`, which `chi answer`, `chi send --wait` with no
+message and `delegate_result` rely on through `ReplyWait.own_turn`). A worker's Bridge snapshot
 names its `chi_version` too.
 `POST/DELETE /api/sessions` and `/stop` rescan the session before answering (`SessionHub#touch`).
 `GET /api/sessions` is the hub's projection too (its sort, paging and total). `Server` always builds
@@ -388,6 +398,7 @@ Engine picks the loop from the effective model's host (`HostRegistry#resolve`):
 |---|---|---|---|
 | Raw prompt | `KernelLoop`, wrapped by `LLM::NativeBackend` | no `api:`, or `llama_cpp`/`mlx`/`omlx` | `Client` (`/completion` or `/v1/completions`), chi's own Gemma/Qwen prompt and tool-call parsing |
 | Chat | `LLM::ChatLoop` | `api: openai` | `LLM::OpenAIChat` (`/v1/chat/completions`, streamed, native tool calls) |
+| Chat | `LLM::ChatLoop` | `api: anthropic` | `LLM::AnthropicMessages` (`/v1/messages`, streamed SSE, native `tool_use`) |
 
 Both return an `LLM::ModelResult` and emit the same stream events; tool calls in
 both go through `ToolRunner` (events, hooks, veto, output cap) and
@@ -428,12 +439,28 @@ threshold puts the model's own `[CONTEXT: …]` line on the tail as a system
 message (docs/internals/context-telemetry.md).
 
 **Adapters.** `Client` (raw-prompt servers) and `LLM::OpenAIChat` (one per host,
-`HostRegistry#adapter_for`) share `LLM::HTTP`: timeouts, TLS for https, a line
-reader for streamed bodies, the retry loop (`retry.*`; network errors, 429 and
+`HostRegistry#adapter_for`, built by `LLM::Adapters` from the host's api) share
+`LLM::HTTP`: timeouts, TLS for https, a line reader for streamed bodies, the retry loop (`retry.*`; network errors, 429 and
 500/502/503/504/529, honouring `Retry-After`; never after a stream has produced
 output) and cancel. Cancel closes the in-flight socket from the
 `CancellationController` listener, so it works on any thread.
 
+`LLM::AnthropicMessages` talks Anthropic's Messages API (`POST {root}/v1/messages`) for the same chat loop:
+ChatLoop builds the same OpenAI-shaped wire messages for every chat host, and the adapter translates them
+(`LLM::AnthropicWire`: the head system message becomes the top-level `system` blocks, tool calls `tool_use` blocks,
+tool messages `tool_result` blocks in one user message, image parts `image` blocks, later system messages user
+text; empty text blocks are never sent). Its answer (`LLM::AnthropicAssembly`) is a `ChatResponse` whose
+`provider_content` holds the content blocks as received, which ChatLoop saves on the model entry as
+`anthropic_content` (string keys, so a resumed session sends the same bytes) and sends back verbatim when the
+adapter `replays_content?` (only for entries whose calls are all paired, never for an interrupted one; earlier
+entries' thinking blocks left out under `reasoning_history: turn`) (thinking blocks
+need their signature and their order among text and `tool_use`). Usage is normalized to the OpenAI shape the rest
+of chi reads (the prompt is input + cache reads + cache writes), stop reasons to the loop's finish reasons
+(`max_tokens` → `length`, `tool_use` → `tool_calls`, `end_turn` → `stop`). A stream is read by content-block index
+from the `data:` lines alone (`event:` lines are not needed); `message_start` / `message_delta` events reach
+`on_delta` with that normalized `usage`, pings not at all, and a block's start or delta counts as shown for the
+first-token limit. Both adapters share their model-list cache (`LLM::ModelListing`).
+
 **Errors.** A failed request raises an `LLM::ProviderError` of one kind:
 `ConnectionError` (`RetryExhausted`), `RateLimited` (`CreditsHeld`: a 402 about
 credit held by in-flight requests, retried after 20 s), `OutOfCredits` (any other
@@ -448,7 +475,7 @@ stream events (server counts, else a chars/4 estimate). Model lists are `LLM::Mo
 server (`/props`), then the host's model list, then config.
 
 **Keys.** A host's API key comes only from the environment variable its
-`api_key_env:` names; it never reaches config.yml, `HOSTS_JSON`, `chi self`,
+`api_key_env:` names; it never reaches config.yml, `SAMAGOTCHI_HOSTS_JSON`, `chi self`,
 logs or events.
 
 ## Other components

data/docs/cli.md

@@ -18,7 +18,7 @@
 - `chi sessions list|stop|restart|archive|unarchive|delete|prune|clean|stats` — manage persisted sessions; `list` shows this git project's, `list --scope=all` every one, a delegated session with `↳ <parent>`, `list --archived` the archived ones too (see [Sessions](sessions.md)). `stats ID` prints a session's cost, tokens and progress (a live worker's `GET stats`, else its saved `analytics.json`; `--format json` one object) without running a model turn. A usage error (an unknown subcommand or flag, a flag missing its value, `stop`, `restart` or `delete` with no ids, a bad `list --format` or `--scope`) exits 2; an unknown or refused session exits 1
 - `chi note [--source NAME] [-m TEXT] (ID|PREFIX)... | --all` — add a context note (TEXT or stdin) to sessions: background the model sees on its next turn; it starts no turn (see [Sessions: Context notes](sessions.md#context-notes))
 - `chi context <add|push|ls|show|refresh|rm|mute|unmute> …` — attach live external text to sessions (a command chi runs every so often, or text pushed in); the model gets a short note when it changes and reads it with `context_read`; `chi context add <URL>` attaches a GitHub PR with the github-pr bundle (see [Attached context](context.md))
-- `chi send [-m TEXT] [--image PATH]... [--cut] (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one takes it at its next step; `--cut` asks it to cut long thinking for it); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead (`--new --continues ID|last:ID` the next link of that session's chain, see [Session chains](sessions.md#session-chains)), and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending; `--format json` prints one JSON object instead; exit 3 a question waits, its options on stderr; exit 4 `--timeout` passed with the turn still running; see [Starting a session](sessions.md#starting-a-session))
+- `chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...` — send a message to sessions as if typed there: a turn starts (or a running one takes it at its next step; `--cut` asks it to cut long thinking for it; `--queue` runs it as a turn of its own after the running one, and `--queue --wait` waits for that turn's own answer); piped stdin goes above `-m` as quoted context, and `--image` attaches images (see [Sessions: Sending a message](sessions.md#sending-a-message)); `--new` starts a session with it instead (`--new --continues ID|last:ID` the next link of that session's chain, see [Session chains](sessions.md#session-chains)), and `--wait` prints the answer (`--wait ID` with no message waits for the next reply without sending; `--format json` prints one JSON object instead; exit 3 a question waits, its options on stderr; exit 4 `--timeout` passed with the turn still running; see [Starting a session](sessions.md#starting-a-session))
 - `chi answer ID --question QID (--option N|LABEL)... [--text T] [--timeout S] [--format json]` (or `--dismiss`) — answer the question a session waits on (the one `chi send --wait` exited 3 with), then wait and print what comes next as `chi send --wait` does: the reply (0), the next question (3), still running after `--timeout` (4). `--option` is 1-based or the label, repeated on a multi-select question; `--text` is free text, or a Deny's reason; `--dismiss` leaves it unanswered and the model finishes its reply. A question no longer open (the web answered first) isn't answered again: it waits for that turn's reply. An option the question doesn't offer exits 2; a worker that is gone exits 1 (`send the task again: chi send --wait -m "…" ID`). An approval can be denied, not allowed, unless `guardrails.parent_approvals: once` (a convention, not a security boundary; see [Guardrails](guardrails.md#approvals-from-a-parent-agent))
 - `chi desktop install|upgrade|uninstall|status` — the macOS "Send to chi" helper: a Service and a ⌃⌥⌘N hotkey that send text or images to a session (live, stopped or new) as a message (⏎, a turn runs) or a context note (⌘⏎) (see [Desktop helper](desktop.md))
 - `chi models [--format text|json] [--timeout S] [TEXT]` — list the models every configured host offers, as the names `--model` takes (see [Listing the models](#listing-the-models))
@@ -298,8 +298,8 @@ and cuts nothing. `/cut TEXT` in a terminal or the web composer (or `chi send --
 once the model has streamed only thinking for `steer.cut_after` seconds (per host/model: `steer_cut_after`; default
 20), now or while your message waits, that generation is cut and the step starts again with your message, marked
 `↪ cut in for your message` (see
-[configuration.md](configuration.md#messages-during-a-running-turn-steer-and-cut)). The web
-composer has no `/queue` yet (it says so and sends nothing). The
+[configuration.md](configuration.md#messages-during-a-running-turn-steer-and-cut)). `/queue TEXT`
+(terminal or web composer, or `chi send --queue`) keeps TEXT for after the turn: it runs as a turn of its own once the running one ends. The
 first answer to an `ask_user_question` wins; the other UIs close their widget.
 An empty answer dismisses the question in every UI. The model is then told
 not to go ahead with what it asked about, or change anything else, and to wait.
@@ -541,12 +541,40 @@ REPL alike:
   20 s)` (it waits for the thinking; the step may end first) or `(cutting is
   off; goes in at the next step)` (`steer.cut_after` is 0, per host/model:
   `steer_cut_after`, or no generation to cut).
-- `/queue TEXT` (plain REPL only) runs TEXT as a turn of its own after this
-  one: `(queued: runs after this turn)`. An attached terminal says
-  `(/queue isn't available in an attached session yet)` and sends nothing (the web
-  composer: `(/queue isn't available in the web yet; …)`).
+- `/queue TEXT` runs TEXT as a turn of its own after this one, in an attached
+  terminal, the plain REPL and the web composer alike: `(queued: runs after this
+  turn)` (the web draws it as a queued bubble until its turn starts). It never
+  merges into the running turn, and a plain line sent after it still does.
+  Several queued lines run one turn each, in the order sent; they still run
+  after a Ctrl-C or a failed turn, and a queued line drops a continue offer as
+  any prompt does. Other terminals show someone else's queued line with the same
+  note. A session whose worker is older than queueing would steer it instead, so
+  it is not sent: `(/queue needs a newer worker: restart it with chi sessions
+  restart, then send again)` (the web shows the refusal under the line). A line
+  with images works the same way: it waits for the turn's end, and the lines
+  sent after it still go in at the next step.
   At the open prompt (no turn running) `/cut TEXT` and `/queue TEXT` run TEXT
   as a normal prompt.
+- **The web composer** has a row above the text field in a session (always
+  there, so the composer never changes height): the keys while idle, and while
+  the turn runs the delivery line, where a message sent now goes in (`↳ goes in after this
+  thinking step · 0:42 · 3k chars`, `… after this tool call (execute · 0:12)`,
+  `… after this answer; the turn may go on`, `… once the card above is
+  answered`), then two links. **Enter** (or Send) is the next step;
+  **Alt+Enter** (Option+Enter) or `queue for after the turn` queues it, like
+  `/queue TEXT`, and the bubble is dashed (`after this turn`), below the
+  running turn's card with the commands queued for its end, until its turn
+  starts; `cut in now` cuts, like `/cut TEXT` (by click only: it throws the
+  thinking away). Cut is enabled only while the step has streamed nothing but
+  thinking and cutting is on for the model (the line says `cuts at about 0:25
+  if you choose cut in now` until the thinking passes `steer_cut_after`, and
+  `cutting is off for <model>` with no cut link when it is 0); the queue link
+  is gone for a worker too old to queue (Alt+Enter then sends nothing, keeps the
+  text and says to restart the worker). A link clicked with an empty composer
+  arms that choice (`cut in now ✓ · Enter sends`); a second click or Esc lets
+  go of it. The echo says what it waits for: `waits for the next step` or
+  `cutting in…`, then `steered`. A phone shows the short form (`↳ after this
+  thinking · 0:42`) with `cut in` and `queue` chips.
 - Commands answer, wait or are refused, by what they do:
   - At once, beside the turn: `/stats`, `/recap`, `/help`, `/context`, a
     plugin's anytime command (`/btw`), and the commands that only show
@@ -700,7 +728,9 @@ approval, a hook's question and the step limit don't): two muted lines
 under its `question → answer` line, the whole text when you open the card,
 in both views and after a reload. The chip at the stage's bottom edge, `N steps · M tool
 calls` with one tick per call, opens the turn view's block right above it (newest step first
-while it runs; a tick opens its step). `▾` folds the stage to its status
+while it runs; a tick opens its step). Below the chip, past a dashed rule, wait the
+messages queued for after the turn and the commands queued for its end; they go into
+the history after the turn's answer. `▾` folds the stage to its status
 row, remembered in this browser. The stage keeps its height while a turn
 runs: it grows, with a short ease, when a card or the answer needs room and gives the room back
 only when the turn moves into the history. When the turn ends the answer shows in
@@ -836,7 +866,7 @@ Notes:
 - Without `--default` the command is session-scoped and does not rewrite config files.
 - With `--default` the new default is written to `~/.config/samagotchi/config.yml` (honoring `XDG_CONFIG_HOME`) and takes effect for all new sessions; the current session's effective model is also updated immediately. Bare aliases and `host:model` are both valid.
 - `--default` and `--alias` change only their one key's line in `config.yml` (`default.model`, or the alias under `model_aliases:`): comments and the rest of the file stay as written, a symlinked file is written through and keeps its mode. When the edited text wouldn't read back as the expected settings (a flow-style section, anchors), chi writes the whole file out from the parsed data instead, which drops its comments.
-- Worker sessions inherit `hosts:` via `SAMAGOTCHI_HOSTS_JSON`.
+- A worker reads `hosts:` from config.yml when it starts (not from the chi that started it).
 - The idle recap uses the session's current model (a switch counts from the next recap), unless `recap: {host_ref, model}` pins one.
 
 ## Session recap
@@ -945,6 +975,8 @@ status> model=Qwen3.6-35B | ⑂ 2 running · 1 waiting | ctx=8.1% (under20) | me
   report none, `api: openai`, at the turn's end).
 - `mem:`: the memories the session read, with its `--memory` list; `muted:` its `--mute` list.
   Up to 8 names each, then `+N`.
+- While a turn runs it ends in `· typing goes in at the next step (/cut, /queue)`; the hint is the first thing dropped
+  on a narrow terminal.
 - The row is cut to the terminal's width. Without a live region (output or input not a terminal,
   `TERM=dumb`) it prints as a line when it changes.
 - `SAMAGOTCHI_STATUS_LINE` / `status.line` (default `on`): `off`, `false` or `0` hides it.

data/docs/configuration.md

@@ -106,7 +106,10 @@ Behavior:
   at its start until it is stopped; the web's model picker lists a `hosts:`
   edit at once). A worker gets the CLI flags of the chi that started it
   through its environment.
-- Workers inherit hosts via `SAMAGOTCHI_HOSTS_JSON` propagated through `SessionManager.spawn_options`.
+- A worker reads `hosts:` from the file as it starts, as every other setting, so a delegate (or any session
+  started later) sees a host added after its parent started. `SAMAGOTCHI_HOSTS_JSON` (a JSON object in the shape
+  of `hosts:`) replaces the file's `hosts:` for the process it is set on, the way specs use it; no worker inherits
+  it (`SessionManager.spawn_options` unsets it).
 
 This lets you run `chi` without repeating common defaults such as model
 and llama host/port on every invocation.
@@ -228,7 +231,8 @@ hosts:
 
 `chi self` shows the variable and whether it is set (`api key  FIREWORKS_API_KEY (set)`).
 
-Every host with `api_key_env:` sends `Authorization: Bearer <key>` on each request,
+Every host with `api_key_env:` sends `Authorization: Bearer <key>` on each request (`api: anthropic`:
+`x-api-key: <key>`, see [Anthropic Messages hosts](#anthropic-messages-hosts)),
 chat or raw-prompt alike, so a llama.cpp started with `--api-key` works as a native
 host too (`chi bootstrap --key-env VAR` writes such an entry). An unset variable
 fails the turn before any request (`set VAR`); a 401/403 names the variable to
@@ -289,6 +293,90 @@ workers, and resumed sessions all use the loop of the model's host. Hosts withou
 `api: openai` keep using the native `/completion`, `/v1/completions`, or oMLX
 transport path.
 
+### Anthropic Messages hosts
+
+`api: anthropic` makes a host talk Anthropic's Messages API (`POST {url}/v1/messages`) through the same chat loop:
+Anthropic's own API, a gateway that serves `/v1/messages`, or a local server that does (Splash). The url is the API
+root **without** `/v1`, as `ANTHROPIC_BASE_URL` takes it (a url that ends in `/v1` is accepted: no second `/v1` is
+added); an entry with neither `url:` nor `host:` talks to `https://api.anthropic.com`. The key goes in the
+`x-api-key` header; `auth: bearer` sends it as `Authorization: Bearer` instead (a gateway or provider that wants
+that), `auth: x-api-key` is the default spelled out. Exactly one of the two headers is sent.
+
+```yaml
+hosts:
+  claude:
+    api: anthropic
+    api_key_env: ANTHROPIC_API_KEY
+  gateway:
+    url: https://gateway.example.com
+    api: anthropic
+    api_key_env: GATEWAY_KEY
+    auth: bearer
+  splash-msg:
+    url: http://192.0.2.10:8000
+    api: anthropic
+```
+
+`auth:` works on any host (`bearer` is the default everywhere but `api: anthropic`).
+
+**Known limit (until the next release):** Claude 5.x models (Opus, Sonnet and Haiku 5.5, Fable 5.1) bind each
+thinking block to the request it came from. When the history before a block changes (the system prompt rebuilt after a
+worker restart or a `/model` switch, a changed tool set, the forget layer's edits), such a model may answer HTTP 400
+"… bound to a different conversation" and the turn fails with that error; `/reasoning-history turn` makes it rarer.
+The next release sends Anthropic's binding controls and recovers from that 400. Fireworks, Splash and other
+non-Claude models are not affected.
+
+The loop, tools, events, hooks and UIs are the chat loop's, as for `api: openai`; only the wire differs: the
+system prompt goes as the request's `system` (later system notes as user text), tool calls as `tool_use` blocks,
+results as `tool_result` blocks, images as `image` blocks; thinking streams into the thinking lane; usage counts
+cache reads and writes into the prompt (so `/stats` shows them). Without `default.max_tokens`, `max_tokens` is the
+model list's `max_tokens` capped at 64000, else 64000 (Messages requires one). chi's OpenAI-only request fields are
+never sent there; `sampling:` passes as written.
+
+Its model list is `GET {url}/v1/models` (every page): Anthropic's shape (the window from `max_input_tokens`, images
+from `capabilities.image_input`) or the OpenAI shape a gateway, Splash or Fireworks serves there (images from
+`input_modalities`, `vision` or `supports_image_input`). A gateway whose list lacks an
+id (a high-availability alias) takes it from the host's declared `models:`, as on any host.
+
+**Dialects.** A provider whose `/v1/messages` departs from Anthropic's gets `dialect:` on its host (only on
+`api: anthropic`; an unknown value, or a dialect on another api, warns once and is ignored). `chi self` names it on
+its `loop` line. `dialect: standard` is the default written out. There is one other dialect today, `fireworks` (Fireworks' Anthropic-compatible API, directly or behind a gateway):
+
+- the key goes as `Authorization: Bearer` (an explicit `auth:` still wins);
+- thinking at `low`/`medium`/`high` is `{type: "adaptive"}` with `output_config.effort`, without `display` (Fireworks'
+  schema has none and refuses unknown fields; it returns thinking by default); a model switched to the budget form gets
+  none either;
+- no `cache_control` breakpoints (Fireworks caches prompt prefixes by itself);
+- `x-session-affinity: <session id>` beside `Session-Id`, so a session stays on one replica, where its cache is.
+
+A host without `dialect:` is standard Anthropic (Claude, Splash). Give each upstream kind its own host entry: when a
+gateway serves both Fireworks models and Claude ids on one url, the Claude ids go on a second entry with the same url
+and no `dialect:` (Claude wants `display: summarized` and the breakpoints).
+
+```yaml
+hosts:
+  work-msg:                               # the work gateway's Messages route, Fireworks behind it
+    url: https://gateway.example.com      # the API root, no /v1 (chi adds /v1/messages)
+    api: anthropic
+    dialect: fireworks                    # Bearer auth, no thinking display, no cache_control, x-session-affinity
+    api_key_env: WORK_API_KEY
+    # auth: x-api-key                     # only if the gateway itself wants that header
+    thinking: medium                      # low|medium|high → output_config.effort; off → thinking disabled
+    models:
+      accounts/fireworks/models/kimi-k2p5:
+        price: {input: 0.6, cache_read: 0.1, output: 2.5}    # example rates: put the gateway's (no cache writes on Fireworks)
+  work-claude:                            # the same gateway's Claude ids: standard Messages
+    url: https://gateway.example.com
+    api: anthropic
+    api_key_env: WORK_API_KEY
+    auth: bearer                          # if the gateway wants Bearer for Claude ids too
+  fireworks:                              # Fireworks directly
+    url: https://api.fireworks.ai/inference
+    api: anthropic
+    dialect: fireworks
+    api_key_env: FIREWORKS_API_KEY
+```
+
 To manually verify a live chat-loop tool round trip, run the gated integration
 spec. It requires the model to call `execute` and return the current UTC date:
 
@@ -372,7 +460,7 @@ system prompt stays the same; a server that swaps models between turns goes unno
 `server (chat_template)`, `name`, `default`); `chi self` shows what config says without asking the server. A chat
 host (`api: openai`) formats nothing itself: its profile comes from the name and only strips thought tags.
 
-Workers get `hosts:` (with `profile:`) through `SAMAGOTCHI_HOSTS_JSON` and read `models:` from the same config file.
+Workers read `hosts:` (with `profile:`) and `models:` from the config file.
 `--profile` reaches the worker a chi starts, but a worker that another process wakes later (`chi web`, `--attach`
 after an idle exit) gets that process's environment, so put a lasting choice in config.
 
@@ -416,8 +504,8 @@ models:
 
 `/model` shows what applies (`sampling: temperature=0.6 presence_penalty=1.5 (hosts.work)`), and each request's
 `stream` line in the debug log carries a `sampling=` field with what was sent. The fields are read every turn, so a
-`/model` switch takes the new model's. A worker gets `hosts:` (with `sampling:`) when it starts, through
-`SAMAGOTCHI_HOSTS_JSON`, and reads `models:` from the config file each turn: after changing a host's `sampling:`,
+`/model` switch takes the new model's. A worker reads `hosts:` (with `sampling:`) from the config file when it
+starts, and `models:` each turn: after changing a host's `sampling:`,
 stop the session's worker (`chi sessions stop`) for it to take effect.
 
 ## Prices
@@ -509,7 +597,13 @@ models:
 - `/model` shows the level and where it came from (`thinking: off (models: qwen3.6-35b-a3b)`, `thinking: low
   (session)`), `/stats` on its `thinking:` line, `chi self` too (a session's own level first when run from its
   commands).
-- The idle recap and plugins' side questions always ask with thinking off, whatever the level.
+- The idle recap, plugins' side questions and a broadcast's triage always ask with thinking off, whatever the
+  level. A model that refuses that gets no thinking fields on an `api: openai` host (its default); on an
+  `api: anthropic` host, where such a model always thinks, it gets adaptive thinking at `low` effort and a limit of
+  at least 4096 tokens, so the thinking leaves room for the answer; a model that refuses that too (one that takes no
+  thinking fields at all) gets none, at the normal limit. What a host refused is kept for the next recap, the next
+  `ctx.ask_model` on the same model, and the rest of a broadcast. A recap and `ctx.ask_model` send the session's id
+  as the turns do (`Session-Id`, and `x-session-affinity` under `dialect: fireworks`); a triage sends none.
 
 What each backend gets:
 
@@ -518,6 +612,20 @@ What each backend gets:
 | native (`/completion`), `qwen36` | an empty thought after the assistant cue, and no turn preamble | no knob: thinking stays as the model has it, one notice |
 | native, `gemma4` | no `<\|think\|>` token at the start of the system prompt | no knob, one notice |
 | chat host (`api: openai`) | `chat_template_kwargs: {enable_thinking: false}` and `reasoning_effort: "none"` | `reasoning_effort: <level>` |
+| Messages host (`api: anthropic`) | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive", display: "summarized"}` and `output_config: {effort: <level>}` |
+| Messages host, `dialect: fireworks` | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive"}` and `output_config: {effort: <level>}` (no `display`) |
+
+On a Messages host `default` sends nothing: the provider's own default, which differs by model (some Claude models
+think adaptively but show no thinking text, their blocks still going back; others, and Splash, don't think at all). A model that refuses `disabled` (current
+Claude models) gets the request again without it, as on any chat host. A model that refuses adaptive thinking
+(older Claude: Haiku 4.5) is switched, once and for the worker's life, to the budget form: `thinking: {type:
+"enabled", budget_tokens: B}` with B 2048 / 8192 / 24576 for low / medium / high and no effort; `max_tokens` always
+stays above the budget (the budget is lowered to leave 1024 for the answer, or `max_tokens` raised to 2048). A
+host that refuses the thinking `display` field gets thinking without it from then on (the level still applies); one
+that refuses `cache_control` gets no cache breakpoints from then on, and a `max_tokens` over the model's output
+limit is sent again with the limit the host names. On any chat host, a model that refuses a sampling field
+(`temperature`, `top_p`, `top_k`; Claude refuses the empty-answer retry's temperature while thinking) gets the
+request again without them, and none of them after.
 
 On chat hosts: llama.cpp honours both off switches but ignores the effort (when its `/props` says
 `chat_template_caps.supports_reasoning_effort: false`, chi says so once per session and host, from the `/props`
@@ -590,10 +698,17 @@ models:
   turns included, and answers HTTP 400 without it: under `turn` every turn after one that thought fails. Set
   `reasoning_history: all` there (the example above). DeepSeek through OpenRouter takes `turn`.
 - `drop` sends none (what chi did before this setting).
+- **On an `api: anthropic` host** the reasoning goes back as the answer's own content blocks, verbatim (thinking
+  blocks with their signatures, in their order among text and `tool_use`), not as `reasoning_content`. The default
+  there is `all`: Claude keeps earlier turns' thinking in context, and leaving it out would rewrite the cached prefix
+  each turn (a Qwen template on Splash drops earlier turns' reasoning itself, so `all` costs nothing there). `turn`
+  leaves earlier turns' thinking blocks out (their text and calls stay), and `drop` counts as `turn`: the running
+  turn's thinking blocks always go back (a tool loop with thinking needs the last reply's). An interrupted reply, or
+  one whose tool calls never got their results, goes back as plain text without its blocks.
 - `all` sends every reply's reasoning, earlier turns too. It sends only the field: a local template that leaves out
   earlier turns' reasoning (Qwen's) needs `preserve_thinking` as well (above).
 - Order, first set wins: the session's own level, `SAMAGOTCHI_REASONING_HISTORY` (the whole process; for A/B runs),
-  the `models:` entry (found the way `profile:` is), the `hosts:` entry, then `turn`. Anything else than a level warns
+  the `models:` entry (found the way `profile:` is), the `hosts:` entry, then `turn` (`all` on `api: anthropic`). Anything else than a level warns
   once and counts as unset. A host's level reaches a worker when it starts, as its `sampling:` does.
 - **A session's own level** (`drop`, `turn` or `all`; an explicit `turn` counts as its own) is saved in the session
   (its file's `"reasoning_history"`), so a `--resume`, a respawned worker, a continue and `/model` keep it; a plugin's
@@ -888,6 +1003,12 @@ many times per turn; `0` ends the turn at the empty answer as before. An answer
 (90 % or more) is not retried. When the retries run out the turn ends with no answer: every UI shows one muted line,
 `no answer: the model returned nothing (after 1 retry)`, and the model is told on its next turn with a hidden note;
 no made-up answer is saved.
+A provider that refuses the answer (a Messages host's `stop_reason: refusal`, or an OpenAI-compatible host's
+`finish_reason: content_filter` with no text) is not asked again: the turn ends with no answer (text streamed before
+a Messages refusal is not kept), every UI shows `no answer: refused by the provider (cyber)` (the category from
+`stop_details`, when there is one), and the hidden note says the answer was refused. A `content_filter` stop after
+some text keeps that text as the answer, followed by `[cut off by the provider's content filter]`, and is not asked
+again either. Tool calls that come with either are not run.
 A generation a plugin cuts while it streams (loop-guard's thinking watch, or any `stop_generation`,
 [hooks.md](hooks.md#watching-the-stream)) uses the same budget: `↻ cut by loop-guard, asking again (1/1)`, and with
 none left the turn ends as cancelled (hook).
@@ -907,7 +1028,8 @@ that model's cut wait (`steer.cut_after` seconds, default `20`, `0` = never; cou
 so the wait for a busy server doesn't count) and still does, and the model starts the step again with the message
 (`↪ cut in for your message`). One that comes earlier cuts once the thinking passes it, unless the step ends first
 and the message goes in there. A plain message (from the web composer, `chi send` without `--cut`, a parent agent)
-never asks for a cut. Such a cut spends no `retry.empty_answer` attempt and sends no hidden note; only the cut
+never asks for a cut, nor does a queued one (`/queue TEXT`, `chi send --queue`, `ctx.sessions.send(…, delivery:
+:queue)`), which runs as a turn of its own after the running one. Such a cut spends no `retry.empty_answer` attempt and sends no hidden note; only the cut
 thinking is lost. A generation that has streamed visible text or a tool call is never cut, and a plugin's steer
 (`ctx.steer`, `ctx.sessions.send`) never cuts.
 
@@ -931,9 +1053,12 @@ models:
 
 `/model` shows the resolved wait (`; steer cut: after 60 s (models: qwen)`, `; steer cut: never (hosts.splash)`).
 
-`/queue TEXT` in the plain REPL runs TEXT as a turn of its own after the running one; the attached terminal and the web
-don't queue yet, and a request that asks the Bridge or the web for `delivery: "queue"` is refused (400
-`delivery_unavailable`).
+`/queue TEXT` (in a terminal or the web composer) runs TEXT as a turn of its own after the running one: the request
+carries `delivery: "queue"`, the input file keeps it, and the worker's drain leaves the file for after the turn. The
+Bridge acks `delivery: "queue"` while a turn runs (to an idle session the message is simply the next turn:
+`next_step`). A worker whose sidecar doesn't name the `delivery` feature (older than queueing) would steer it, so the
+sender refuses it (`409 delivery_unavailable`, "restart it"), and so does a worker that answers the request with a
+400 `delivery_unavailable`.
 
 ## Server errors
 
@@ -952,6 +1077,13 @@ message (before, a failed llama.cpp `/completion` ended the turn as
 | bad request | other 4xx; a prompt larger than the context window, whatever the status | no |
 | protocol | a body the API doesn't promise | no |
 
+An error event (or an error body inside a 200) has no HTTP status of its own: its numeric `error.code` stands for
+one, or a Google-style code name (Fireworks: `INVALID_ARGUMENT` 400, `UNAUTHENTICATED` 401, `PERMISSION_DENIED` 403,
+`NOT_FOUND` 404, `RESOURCE_EXHAUSTED` 429), else its `error.type` (Anthropic's names; some OpenAI-compatible servers,
+OpenAI and Ollama, use some of them: `invalid_request_error` 400, `authentication_error` 401, `billing_error` 402,
+`permission_error` 403, `not_found_error` 404, `request_too_large` 413, `rate_limit_error` 429, `api_error` 500,
+`timeout_error` 504, `overloaded_error` 529); with neither it counts as a 500.
+
 The turn's prompt and its completed tool calls stay in the session.
 
 ## Debug Log File

data/docs/internals/engine.md

@@ -54,8 +54,10 @@ Engine#run_turn(session, prompt, on_event:, max_iterations:, cancel_controller:,
   │
   ├── complete_turn(turn, result)
   │     # end_turn(turn, "completed" | "canceled"): under the event lock the session gets the kept
-  │     #   messages, goes IDLE, records last_turn, and :turn_completed {result, turn_summary,
-  │     #   display_pending} or :turn_canceled {cancellation_reason, cancelled_by, duration_ms} is emitted
+  │     #   messages, goes IDLE, records last_turn (enqueued_id: the turn's input, from its origin;
+  │     #   a continue turn's origin carries its offer turn's, ContinueOffer#run_continue_turn),
+  │     #   and :turn_completed {result, turn_summary, display_pending} or :turn_canceled
+  │     #   {cancellation_reason, cancelled_by, duration_ms} is emitted
   │     # then the :after_turn hook (status, messages, present: the AnswerDisplay presenter,
   │     #   refs: the AnswerRefs adder)
   │     # store_answer_display (one replace of the answer: `display` and/or `display_refs`;
@@ -127,8 +129,8 @@ The Engine does not talk to models directly. `Engine#backend` picks the loop the
 
 ```
 Engine#backend → backend_for(@host_registry.resolve(@effective_model_name))
-  → host entry chat? (api: openai): LLM::ChatLoop (one per Engine, built on first use)
-  → else:                           LLM::NativeBackend wrapping the Engine's KernelLoop
+  → host entry chat? (an api in LLM::Adapters::BY_API: openai, anthropic): LLM::ChatLoop (one per Engine, built on first use)
+  → else:                                                     LLM::NativeBackend wrapping the Engine's KernelLoop
 ```
 
 Both implement the `LLM::ModelBackend` contract (`#complete(messages:, max_iterations:, on_stream_event:,
@@ -208,7 +210,10 @@ The differences from the native loop:
 - A 400 about reasoning (`BadRequest#reasoning_refused?`) for a request that sent reasoning back asks the step again
   without it; when that goes through, `#reasoning_history_refused!` marks the model (worker lifetime) and
   `:reasoning_history_refused` goes out. When it is refused too, the thinking-fields fallback (`#thinking_refused!`,
-  `:thinking_refused`) runs on it, still without reasoning. Up to three requests per step.
+  `:thinking_refused`) runs on it, still without reasoning. Up to three requests per step. A 400 about a thinking
+  block's signature (`BadRequest#thinking_signature?`) or a refused binding control
+  (`#thinking_binding_unsupported?`) is not one: `ProviderErrors` leaves `reasoning_refused?` false for them, so one
+  bad block never turns reasoning off for the model.
 
 ### Shared: ToolResponse (per batch) and ToolRunner (per call)
 
@@ -341,6 +346,10 @@ What the running generation streams, fed by the Engine's stream handler: whether
 Bridge acks it as `cut`.
 A generation is cuttable while it has streamed only thinking, is still thinking, and has thought for at least
 the model's cut wait (`SteerCutAfter.resolve`: `steer_cut_after` per models:/hosts: entry, else `steer.cut_after`) seconds (`cuttable?(min_age)`). It has `started!`, `chunk!`, `retrying!` and `finished!`.
+`snapshot` is the running generation as `GenerationPhase::Snapshot` `{thinking_only, age}` (nil with none running;
+`age`: its thinking's seconds, nil before any): `SteerCut#generation_snapshot` → `Engine#generation_snapshot`, which
+`Bridge#snapshot` merges into `current_turn.generation`, so a web page joining mid-generation can clock its delivery
+line and tell whether "cut in now" can land.
 
 ### WaitingSteer
 
@@ -518,10 +527,20 @@ Both loops:
   The retry request runs at temperature 0.6 when the configured sampling sets no temperature; a configured one
   is kept. A length stop with the context at least 90% full is not retried. When the retries run out, the
   Engine keeps a `TurnNote.empty` note as the turn's end.
+- **A refusal** (chat loop only): a finish reason `refusal` (Messages), or `content_filter` (OpenAI) with no text, is
+  an empty answer never retried; text streamed before a refusal is not kept, and tool calls with it are not run. A
+  `content_filter` with text keeps it, marked `ChatLoop::FILTERED_MARK`, also never retried. `ModelResult#refusal` is `{category:}` (from the response's
+  `stop_details`) or `{}`, and goes on the `TurnNote.empty` marker and `turn_summary.empty_answer` as `refusal`, so
+  every UI words the notice `no answer: refused by the provider (cyber)`.
 - **A cut generation** (`after_cut`): a generation a plugin cut (`stop_generation`) spends the same retry budget
   with its own nudge; when it is used up, the turn ends cancelled (`:hook`). A steer's cut asks again with the
   steer and spends nothing.
-- **Steering**: queued input goes in at iteration boundaries (`Steer.inject!`, `:pending_input_merged`).
+- **Steering**: queued input goes in at iteration boundaries (`Steer.inject!`, `:pending_input_merged`). A
+  worker's drain (`Worker#pending_input_drain`) takes every input file in name order except the ones
+  `SessionInbox.waits_for_turn_end?` leaves for a turn of their own (`delivery: queue`, or images): those are
+  skipped, not a barrier, so a line sent after them still merges. Only the files it claims reach
+  `:input_merged`, the failure hand-back (`@merged_this_turn`) and the checkpoint; the skipped ones run after the
+  turn, one turn each, in name order (`Worker#run_input_files`).
 - **Context status**: an estimate of the window's fill before each request,
   emitted on every request (`:context_status`) so the UI always has a current
   number, with a guidance line on the tail only when it rises far enough.