samagotchi 0.46.0 → 0.46.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fb03f917133e78236dfb0bf16eae6c21b00ec2fb3720501d6c1982aeb9dc220
-  data.tar.gz: b3edff20b87e1f954c6079cd0315ab64559a5814f9a64e92e215fedc745a2778
+  metadata.gz: 9143ff1fecadcc026c2e0b079d61551359985d72d080f33fc7074af8f90402c1
+  data.tar.gz: 04d7e899417b9684ac61d337361ca91e8fa58dcdd091611109fcfff677a351ba
 SHA512:
-  metadata.gz: 96b8d90741656cae236454b5f1b56f49e77ad1a511eb81cdc31594b311031b57363993091ae0df70cf78c6f346a2b6b867896b53e0093ae2e59671146cd12eb6
-  data.tar.gz: 6041ee413db16da9147f763f83cfabcf91e0c62ea95380fa8ae454aab9e242b646501fafdd2ed5071008b4b218ad740c585517ee1e3cd0fb84531cb36a43d59d
+  metadata.gz: 272e94da604a43b0d3b6f405dc7b2bbe420e4c7adffc9fba6b8c5ecf52811b4411c4fce03e32e85e00ee60b1f30b395daf107a459e842e196803d08658bcfdf0
+  data.tar.gz: b3262e257e88b57a739e61c3774d5c2bbef910956fcd9fc6ef726275ddc4bbc10a59ee70a1a9236a50aada19e9663338e32077720bfc1d6b0db6fcbf7e059a43

data/CHANGELOG.md

@@ -8,6 +8,46 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.46.1] - 2026-10-09
+
+### Changed
+
+- The terminal and the web word a retry line the same: `↻ retrying (503) in 4.0s, 2/5`, why in parens (the HTTP
+  status, the error's short name such as `ECONNREFUSED`, or `stream dropped`), the wait with one decimal, and the
+  retry of all there will be. The terminal said `retrying (2/5 in 4.0s)`, the web `↻ retrying (503) in 4 s, 2/5`.
+
+### Fixed
+
+- A question the model asks in a `chi -p --non-interactive` run no longer tells the model the user dismissed it:
+  it is told no one could answer (a non-interactive run). The question closes with reason `non_interactive`.
+- The web's card for a question closed that way reads "No one could answer (non-interactive run)", not
+  "Cancelled (non_interactive)".
+- A delegate's report read by a turn that ended canceled is no longer brought a second time when the Engine's
+  post-turn work then fails (a full disk, say).
+- github-pr 0.3.3: a `path:line` into a vendored copy (`vendor/lib/foo.rb:21`, or `/abs/repo/vendor/lib/foo.rb:21`)
+  is no longer linked to the PR's `lib/foo.rb` in the web: an absolute path's part before the PR path must be a
+  worktree's root (a directory with `.git`), or no directory on this machine. An absolute path into a worktree, or
+  one up from a subdir (`../lib/foo.rb`), still is.
+- A step whose stream kept dropping now fails saying how many requests it made ("after 3 attempts"), not
+  "after 1 attempts"; one attempt is said in the singular.
+- A step that ends on another error after its stream dropped (a 503) counts the dropped requests in that
+  error's attempts too, and a step asked again without thinking fields (a host refused them) keeps its count of
+  stream drops: it no longer gets two more ask-agains of its own.
+- A host that is down is named once in the models list's warning and in `/models` (`gw: connection refused`, not
+  `gw: gw: connection refused`).
+- A host whose model listing kept failing on network errors is named once too, in the models list's warning, the
+  web's and `/models` (`gw: request failed after 3 attempts: …`, not `gw: gw request failed after …`).
+- `/stats`' estimated cost names the host whose prices it used (`from hosts.gw.models prices`), not a literal
+  `hosts.<name>.models`.
+- The config warning for a model price's old `cached` key suggests `cache_read`, its new name.
+- The web's ⚠ for a model the server served instead of the one asked now shows on a session opened with no
+  worker running too (from its saved analytics), not only while its worker runs.
+- A host whose `/v1/models` fails no longer drops the ids declared under `hosts.<name>.models` from `chi models`,
+  `/models` and the web model picker: they stay, marked `host down` (greyed in the picker, still pickable;
+  `unavailable: true` in the JSON), next to the host's warning. Ids only the host itself lists still drop out.
+
+Update with `chi update`: it updates github-pr (0.3.3: no links from a vendored copy to the PR's file).
+
 ## [0.46.0] - 2026-10-09
 
 ### Added
@@ -2143,7 +2183,8 @@ 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.46.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.46.1...HEAD
+[0.46.1]: https://github.com/dm1try/samagotchi/compare/v0.46.0...v0.46.1
 [0.46.0]: https://github.com/dm1try/samagotchi/compare/v0.45.0...v0.46.0
 [0.45.0]: https://github.com/dm1try/samagotchi/compare/v0.44.0...v0.45.0
 [0.44.0]: https://github.com/dm1try/samagotchi/compare/v0.43.0...v0.44.0

data/docs/cli.md

@@ -87,15 +87,18 @@ $ chi models qwen                # only the names containing "qwen" (any case)
 
 - A host's ids declared under `hosts.<name>.models` (see
   [configuration](configuration.md#models-a-host-serves-but-doesnt-list)) come first under that host, listed or not,
-  as plain names like any other.
+  as plain names like any other. They stay when the host fails, and its stderr warning says so
+  (`chi models: box: connection refused (its declared ids are still listed)`).
 - A default-host id is bare, except one with a `:` (`qwen3:8b`), which is written `<host>:qwen3:8b` so it can't
   read as a host name. An id that an alias of the same name hides is left out.
 - Each run lists anew (no cache); `--timeout S` caps the wait for the hosts (default 4 s). A host that fails or doesn't
   answer in time is noted on stderr (`chi models: box: no answer in 4 s`).
 - `--format json` prints one object: `default` (and `default_typed` when it was set as an alias), `default_host`,
-  `models` (`name`, `host`, `id`, and `configured: true` on an id declared under `hosts.<name>.models`), `aliases` (`name`, `ref`, `host`) and `warnings`. The desktop helper's model
+  `models` (`name`, `host`, `id`, and `configured: true` on an id declared under `hosts.<name>.models`,
+  `unavailable: true` too when that host failed to list its models), `aliases` (`name`, `ref`, `host`) and `warnings`. The desktop helper's model
   chooser reads it.
-- Exit 0 when any host listed its models, 1 when none did (the default is still printed), 2 on a usage error.
+- Exit 0 when any host listed its models, 1 when none did (the default and declared names still print), 2 on a
+  usage error.
 
 ### Updating
 
@@ -250,7 +253,8 @@ Notes:
   cancel note and exits 130.
   Nobody can answer there: an approval is denied, and a question the model
   asks (`ask_user_question`) is dismissed at once (one line on stderr), never
-  read from stdin, so the model finishes its reply.
+  read from stdin. The model is told no one could answer (a non-interactive
+  run), not that you dismissed it, and finishes its reply.
 
 ### Scratch sessions
 
@@ -438,7 +442,7 @@ thinking cuts (generations a plugin such as loop-guard cut) and output cap hits
 (generations that ended at the provider's cap), context used and window (the used figure is counted against the smaller of the window and the session's LLM context budget, and says so: `context used:     16000 tokens (25.0% of the 64000 budget)`), the memory indexes the session's prompt holds ([Memory](memory.md#the-indexs-size)), the model notes it carried (`model notes:      model_notes_deepseek (system, 612 chars)`, none without any; [Memory](memory.md#model-notes)), the prompt profile and the model the server says it ran, and the
 cost when the provider reports one (OpenRouter's `usage.cost`), and the cost
 estimated from a price under `hosts.<name>.models` when it reports none or 0,
-marked `~` (`cost:             $0.42 reported + ~$0.12 from hosts.<name>.models prices (this session only)`;
+marked `~` and naming the current model's host (`cost:             $0.42 reported + ~$0.12 from hosts.gw.models prices (this session only)`;
 see "Prices" in [configuration](configuration.md#prices)). The speed line is the last generation's and the session's average
 (weighted by tokens): llama.cpp reports it exactly (`87 tok/s out, 1.9k tok/s
 prompt (last, server)`); for other servers it is estimated from the first
@@ -742,7 +746,7 @@ In interactive assist mode, you can switch the request model without restarting:
 - `/model`: show the effective model (and default when diverged: `runtime model: <effective> (default: <default>, profile=<name>, <source>)`, e.g. `profile=qwen36, server (chat_template)`). When the session's prompt carries model notes the line ends with `; notes: model_notes_deepseek (system, 612 chars)`; a switch's `runtime model set to …` names the new model's ([Memory](memory.md#model-notes)).
 - `/model clear` (or `default`/`none`/`off`): clear the session override, reverting to the configured default.
 - `/guardrails`: the guardrail rules (by source), what failed to load, and your stored approvals, numbered; `/guardrails revoke N` removes approval N (see [Guardrails](guardrails.md)).
-- `/models`: list model ids aggregated across all `hosts:` (an alias shows next to its id: a bare alias on every host listing the id, a `host:model` one only under its host; grouped `host (host:port):` with per-host `unreachable` warnings, e.g. an unset `api_key_env`; lists cached 60s, 10 minutes for a remote host; lazy — no startup prefill). Ids the host declares under `hosts.<name>.models` come first, as `rr/x (config)`, and don't count toward the cap. At most 20 ids per host, then `… and N more`; `/models <text>` lists every id containing `<text>` (any case), e.g. `/models qwen` on OpenRouter.
+- `/models`: list model ids aggregated across all `hosts:` (an alias shows next to its id: a bare alias on every host listing the id, a `host:model` one only under its host; grouped `host (host:port):` with per-host `unreachable` warnings, e.g. an unset `api_key_env`; lists cached 60s, 10 minutes for a remote host; lazy — no startup prefill). Ids the host declares under `hosts.<name>.models` come first, as `rr/x (config)`, and don't count toward the cap; an unreachable host keeps them, under its warning, as `rr/x (config, host down)`. At most 20 ids per host, then `… and N more`; `/models <text>` lists every id containing `<text>` (any case), e.g. `/models qwen` on OpenRouter.
 
 Notes:
 
@@ -893,7 +897,9 @@ While a turn runs, one row above the prompt says what it is doing, the spinner f
   Qwen `TURN:` prefix and inline markdown are left out.
 - `| waiting for the first token… 5s` after 2 s with nothing streamed.
 - `| running execute…` while a tool runs (its `tool>` line prints when it ends).
-- `| retrying (1/3 in 0.5s): Errno::ECONNREFUSED` while a network error is retried.
+- `| ↻ retrying (ECONNREFUSED) in 0.5s, 1/3` while a failed request is asked again: why (the HTTP status such as
+  `503`, the error such as `ECONNREFUSED`, or `stream dropped`), the wait, and the retry of all there will be.
+  The web's timing line words it the same.
 - `| mcp: starting servers…` while a plugin's slow setup (an init task) runs, between turns too;
   `mcp> ✓ …` prints when it is done.
 

data/docs/configuration.md

@@ -774,7 +774,9 @@ and a plugin's steer (`ctx.steer`, `ctx.sessions.send`) never cuts.
 
 Assist-mode UX:
 
-- While waiting, retry notices are rendered in the existing thinking spinner area as a red `network error: retrying ...` status.
+- While waiting, a retry shows in the activity row (the web's timing line words it the same):
+  `↻ retrying (503) in 4.0s, 2/5`: why (the HTTP status, the error's short name such as `ECONNREFUSED`, or
+  `stream dropped`), the wait, and the retry of all there will be.
 - If retry attempts are exhausted, the submitted prompt is restored into the input editor so you can edit and resubmit.
 
 ## Server errors

data/docs/desktop.md

@@ -62,7 +62,8 @@ for an alias), your recent picks and every host's
 models and aliases (from [`chi models`](cli.md#listing-the-models)), at most nine at a time.
 
 - Type to search: every word must match the host or the id; names starting with what you typed rank first. A name
-  no host lists is offered at the bottom as "not listed" and sent as typed (a host that is down, a model just added).
+  no host lists is offered at the bottom as "not listed" and sent as typed (a model just added, or one a down host
+  doesn't declare: a down host's `hosts.<name>.models` ids stay in the list).
 - ↑/↓ and ⏎, a click, or ⌘1…⌘9 pick; Esc (or ⌘M) closes the chooser only, a second Esc the panel. While an input
   method is composing, ⏎, the arrows and Esc are its own.
 - The row then shows the pick in the accent colour, and ⏎ sends `chi send --new --model <name>`, the name exactly as

data/docs/sessions.md

@@ -65,7 +65,7 @@ chi sessions clean --dry-run --days 7            # test sessions older than 7 da
 **Ordering:**
 
 - `Session.list` / `SessionManager.list_sessions` / `GET /api/sessions?sort=&order=&limit=&offset=` default to `updated_at desc` (newest activity first). Also supports `created_at`, `asc`. `X-Total-Count` header when paginated.
-- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only (one estimated from a `hosts.<name>.models` price shows with `~`: `cost: ~$0.54 ($0.42 reported, ~$0.12 estimated)`), and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first (an id the host declares under `hosts.<name>.models` first, noted `config`, its tooltip `served by config (hosts.<name>.models)`); typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, configured?, sampling?, llm_context?}], warning?}`; `configured: true` marks an id declared under `hosts.<name>.models`, listed first under its host; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). Beside it, an `llm ctx` chip shows the LLM context the picked model starts under (each `GET /api/models` row's `llm_context`, as the info bar's); its form sets one for the new chat only, sent as `POST /api/sessions`'s `llm_context` and never remembered (see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last model picked; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
+- Web UI (`chi web`): the page's scope is in its URL. Started in a git repo, `chi web` opens `/?dir=<that folder>`: that project's sessions, and new chats start in that folder; the header chip says `<project> · all`, and `all` opens the same place without `?dir` (every session; a new chat there starts in the server's own folder, shown on the start page, and cards name their folder; `← <project>` goes back to the project view it came from, or to the server's own project). One server serves every project: a second `chi web` (from another repo) finds it through `GET /api/info` and prints (with `--open`, opens) its page for its own folder instead of starting another. The 3 latest sessions sit above the chat (`hide ▴` puts them away behind a `▾ N sessions` pill, remembered; in a window under 900 px wide, where the strip scrolls sideways, `▴ hide` sits in the top bar where the pill comes back; a window under 700 px tall hides them by itself, so a question or approval card in the stage keeps room, and the pill shows them until the window is tall again). A parent and its delegates are one card there: its `▸ 2 delegates · 1 live · 1 waiting` chip (the waiting part in the attention colour, the card's border too) opens their rows in a popover under it (a row per delegate at any depth, indented; a click opens that one, Esc or a click outside closes it, and the strip's order holds while it is open). A fork is a card of its own, and so is a delegate whose parent isn't listed (archived, another project), with its `↳ <parent>` chip; the pill counts cards, and every live or waiting session. "All sessions" (or `/`) opens every session at `#/sessions`, with a search over preview, id and status (Esc or Back returns). There a parent's card holds its delegates the same way, the chip opening their rows inside the card (each with an archive button on hover), open by itself while one of them waits on you; the count says `14 (+7 delegates)`, a search that matches a delegate shows its parent's card with the list open and the matching rows marked, and select mode picks cards (archiving a parent takes its delegates). The open session is in the URL (`#/s/<id>`), so a reload or a copied link opens it again; the chi logo top left goes back to the empty start for a new chat. The message box grows with its text; drag its top edge to keep it taller (double-click resets). The info bar copies `chi --attach <id>` for a terminal. A session whose prompt carried model notes has a `notes: deepseek` chip there (the names without `model_notes_`; the tooltip lists each with its scope and size; `session.prompt_notes` in `GET /api/sessions/:id`, the live worker's, else the session file's; see [Memory](memory.md#model-notes)). Its `llm ctx` chip names the LLM context strategy the next turn runs under (`llm ctx stale,forget · session`, in the accent colour when the session set its own; the tooltip gives each value's source), and its popover sets the session's own strategy, apply rule and budget, or follows the model again, by running `/llm-context` in the worker (the reply shows as a command bubble); `GET /api/sessions/:id`'s `session.llm_context` carries the values (the live worker's, else resolved from the session file), and a `command_ran` that changed them carries the new ones. It shows the context used (`ctx 42%`) and the last generation's decode speed (`87 tok/s`, `~64 tok/s` when estimated; see `/stats` in [cli.md](cli.md#session-commands)); hovering `ctx` there or on a session card lists the session's tokens in (summed over every request, with the cached share), out (with reasoning) and the cost when the provider reports one, for this session only (one estimated from a `hosts.<name>.models` price shows with `~`: `cost: ~$0.54 ($0.42 reported, ~$0.12 estimated)`), and the memory indexes its prompt holds (`memory index: ~3.4k tokens in this session's prompt (system 2.0k, project 1.4k)`; see [Memory](memory.md#the-indexs-size)). The start page's model picker (bottom left of the composer, the chosen name `▾`) chooses the model a new chat starts on; it opens a search list over the conversation (↓ or a click; downward when the start page leaves no room above): an empty search shows the last 5 picks (Recent) and then each host's model ids A–Z under the host, the default host first (an id the host declares under `hosts.<name>.models` first, noted `config`, its tooltip `served by config (hosts.<name>.models)`; a host that failed to list its models keeps those ids, greyed and noted `host down`, still pickable; a remembered or default model stays chosen even then, greyed on the button); typed words must each match the host or the id (a substring, else for 3+ characters the letters in order, so `deepseek4.1 fla` finds `openrouter · deepseek/deepseek-v4.1-flash`), ⏎ picks, Esc/Tab close, a pick puts the focus in the message box: `GET /api/models` lists the hosts' models as chi spells them (`{default, models: [{name, host, id, configured?, unavailable?, sampling?, llm_context?}], warning?}`; `configured: true` marks an id declared under `hosts.<name>.models`, listed first under its host, `unavailable: true` one whose host failed to list its models; `sampling` is the model's configured request parameters as `/model` words them, the row's tooltip in the list; bare for the default host, `host:model` for the others, from the same cached lists as `/models`, a bounded wait, a host that is down noted in `warning`), and `POST /api/sessions` takes `model` (blank means the default). Beside it, an `llm ctx` chip shows the LLM context the picked model starts under (each `GET /api/models` row's `llm_context`, as the info bar's); its form sets one for the new chat only, sent as `POST /api/sessions`'s `llm_context` and never remembered (see [configuration.md](configuration.md#llm-context-a-sessions-own-strategy)). The start page's first message goes as later ones do: `POST /api/sessions` with `idle: true` and `preview` (the message, which names the session until its turn is saved), then `POST /api/sessions/:id/turn`, so a failed first turn puts its prompt back in the composer too; a first line that is one of the new session's commands (`/model …`) goes to `POST /api/sessions/:id/command` instead, as later ones do. The browser remembers the last model picked; a running session's model is in the info bar and changes only with `/model`. In the composer a line is a command when it is `!…` or starts with one of the session's command names (its `commands` list; `/stats`, `/exit` and the other terminal words get the page's own reply); an unknown `/word` (`/usr/bin/env is missing`) goes to the model as a prompt, as in a terminal; a one-word `/word` no command answers (`/modle`) is not sent: the page shows `Unknown command /modle. Did you mean /model? /help lists the commands.` (the "Did you mean" part only when a name is close). A `POST /turn` (or a session's first `prompt`) that is one of the worker's commands runs as that command too (`202 {status, command_id, session_id}`), so `chi send`, `chi -p` and a page whose command list lags all get the command. ↑/↓ in the composer walk the prompt history the TUI's ↑ walks ([Persistent Prompt History](cli.md#persistent-prompt-history)): ↑ with the caret on the first line, ↓ from the last line while browsing, ↓ past the newest brings the draft back; `GET /api/history` returns `{entries: [...]}`, oldest first (the page fetches it on focus and after each send). The server records a sent line in the routes once the worker took it (`POST /turn` accepted, a `!command` through `POST /command` or as a session's first line); `"history": false` in the body keeps it out (an image-only send).
 - Web notifications: when a session needs you while the tab is hidden or behind another window (a question or a guardrail approval, a plugin card with buttons during a turn such as check-in's, a failed turn, a turn done after 10 s or more; a delegated session only for its questions, a canceled turn never), the page title counts it, `(N) Chi`, until you come back to the tab. The bell at the right of the top bar also turns on OS notifications ("needs an answer", "needs approval", "needs you", "turn failed", "done in 42 s", under the session's first message; a click opens the session): its first click asks the browser for the permission, and the choice is kept per browser. Any session of the page's scope counts, not only the open one. What was already so when the page loaded never counts, and several chi tabs show one notification per event. A chi tab in front tells the others (a `BroadcastChannel`), so while you look at one, the ones behind neither notify nor count what it shows; coming back to a tab clears those events in the other tabs' titles too. The hub's `session` frames carry what this needs: `pending_question` (`{id, kind}`, kind `question` or `approval`), `pending_card` (`{id, bundle}`: the running turn's card with actions, from `pending_card.json` that the worker keeps in the session's folder while one is open; a card without actions, such as loop-guard's, never counts) and `last_turn` (`{outcome, ended_at, seconds, origin}`, saved in the session's JSON as the engine ends each turn).
 - The web frontend is a zero-build ES-module stack in `lib/samagotchi/web/public/`: `data.js` (retrieval, typed SSE `openStream` for a session and `openEvents` for the session list), `sessions_list.js` (the list as a pure reducer over `GET /api/events`: a snapshot replaces it, an upsert keeps a known card in place, a removal drops it; `families()` groups delegates under their parent), `families_view.js` (a parent's family chip, its rows and the strip's popover), `notify.js` (which of those events needs the user, for the notifications), `app.js` (presentation/state; a session with no live stream gets one when its `session` event says `bridge_up`, after one re-read: `event_seq` starts over in each worker, so a dropped stream is never resumed with its old cursor), `format.js` (pure formatters such as `previewOf`), `prompt_history.js` (the composer's ↑/↓ over the shared prompt history). Unit-tested via `npm test` (`node --test spec/web/public/*.test.js`).
 - Selecting a session in the web UI is read-only: `GET /api/sessions/:id` never spawns a worker (it reads a live worker's snapshot when one runs, else the session file). A prompt (`POST /turn`) or a command (`POST /command`) wakes the worker, and `/stream` briefly waits for a freshly-spawned bridge before answering. A caught-up SSE reconnect holds the stream open; `reset` markers are only sent for reconnects behind the ring window, or with a cursor from another worker (event ids are `<event_seq>-<epoch>`, one epoch per worker).

data/lib/samagotchi/bundles/github-pr/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: github-pr
-version: 0.3.1
+version: 0.3.3
 scope: system
 description: Attaches the branch's open GitHub pull request to a session as context (and any PR URL with chi context add or the web's "+ URL"); the agent gets a note when reviews, comments, checks or its state change; in the web, a path:line in an answer links to that line of the PR; the auto_attach setting can offer the PR with a card first, or attach nothing
 trust_level: reviewed
@@ -11,7 +11,7 @@ needs:
   hint: brew install gh, then gh auth login
 plugin:
   file: plugin.rb
-  sha256: sha256:eb6207a0aec4267eb15d28e4db2edb10d458c3ff574c2be56f225b24b7afb733
+  sha256: sha256:f68b53bfb552e35c9b151ee42cc10c07923481fc3d5496f023422e388df6719a
 scripts:
   pr_context.rb: sha256:a883d2780e89c68c0d7b6d5e0fcb22c273f17bb167e79064e0e99db6bd2ee6f0
 context_providers:

data/lib/samagotchi/bundles/github-pr/plugin.rb

@@ -616,21 +616,42 @@ class LineLinker
   end
 
   # The PR file +path+ names: the path (or a rename's old one) exactly,
-  # after a leading `./`; else the longest PR path +path+ ends with on a
-  # `/` boundary (an absolute path into a worktree); else the one PR path
-  # that ends with +path+ (a bare `foo.rb`). nil: none, or several.
+  # after a leading `./`; else, for an absolute path (into a worktree) or
+  # one up from the cwd (`../lib/foo.rb` from a subdir), the longest PR
+  # path it ends with on a `/` boundary (see #worktree_suffix); else the
+  # one PR path that ends with +path+ (a bare `foo.rb`). nil: none, or
+  # several. A relative path that only ends with a PR path
+  # (`vendor/lib/foo.rb`) is another file.
   def resolve(files, path)
     path = path.sub(%r{\A(?:\./)+}, "")
     exact = files.find { |file| file.path == path } || files.find { |file| file.previous_path == path }
     return exact if exact
 
-    longer = files.select { |file| path.end_with?("/#{file.path}") }.max_by { |file| file.path.length }
-    return longer if longer
+    if path.start_with?("/", "~/", "../")
+      longer = files.select { |file| path.end_with?("/#{file.path}") }.sort_by { |file| -file.path.length }
+      return path.start_with?("../") ? longer.first : worktree_suffix(longer, path)
+    end
 
     shorter = files.select { |file| file.path.end_with?("/#{path}") }
     shorter.one? ? shorter.first : nil
   end
 
+  # The first of +files+ (longest path first) that the absolute +path+
+  # names inside a worktree: the part before the PR path is a directory
+  # with a `.git` (/abs/repo/vendor/lib/foo.rb is a vendored copy, not the
+  # PR's lib/foo.rb), or no directory here at all (a path from elsewhere;
+  # nothing to tell by). nil: each part before is a directory, none a
+  # worktree's root.
+  def worktree_suffix(files, path)
+    full = File.expand_path(path)
+    files.find do |file|
+      root = full.delete_suffix("/#{file.path}")
+      !File.directory?(root) || File.exist?(File.join(root, ".git"))
+    end
+  rescue ArgumentError
+    files.first
+  end
+
   # The PR's Files changed anchor when the lines are inside one hunk (the
   # new side; a removed file's old side), else the file at the PR's head
   # (a removed one: at its base), which has every line.

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,6 +1,6 @@
 ---
 name: samagotchi-system
-version: 0.46.0
+version: 0.46.1
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:

data/lib/samagotchi/config.rb

@@ -636,11 +636,15 @@ module Samagotchi
         end
       end
 
+      # A price key's old name: the warning suggests the new one.
+      RENAMED_PRICE_KEYS = { "cached" => "cache_read" }.freeze
+
       def price_key_problems(prefix, price)
         return [] unless price.is_a?(Hash)
 
         (price.keys.map(&:to_s) - ModelPrice::KEYS).map do |k|
-          unknown_key_message("#{prefix}#{k}", k, ModelPrice::KEYS, prefix: prefix)
+          # A renamed key is compared by its new name, so that name is the hint.
+          unknown_key_message("#{prefix}#{k}", RENAMED_PRICE_KEYS.fetch(k, k), ModelPrice::KEYS, prefix: prefix)
         end
       end
 

data/lib/samagotchi/engine.rb

@@ -945,6 +945,8 @@ module Samagotchi
     # context window, the served model and (on a native host) the prompt
     # profile come from the effective model's server, so this may make one
     # short /props GET; the cheap #session_state_snapshot never does.
+    # price_host: the effective model's host, whose hosts.<name>.models
+    # prices the cost estimate names.
     # @return [Hash] @metrics.snapshot, filled in
     def stats_snapshot
       snapshot = @metrics.snapshot
@@ -952,7 +954,7 @@ module Samagotchi
       served, served_for = served_model_for(snapshot, target: target)
       snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
                                 served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
-                                prompt_notes: prompt_notes.map(&:to_h))
+                                prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1051,8 +1053,7 @@ module Samagotchi
     # warn about. nil when none does.
     # @return [String, nil]
     def served_expected_by(served, target: nil)
-      target ||= @host_registry.resolve(@effective_model_name)
-      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+      ServedModel.expected_by(target || @host_registry.resolve(@effective_model_name), served)
     rescue StandardError
       nil
     end
@@ -1447,8 +1448,6 @@ module Samagotchi
       @question_desk.request(payload)
     end
 
-    QUESTION_DISMISSED_NOTE = QuestionDesk::DISMISSED_NOTE
-
     # Open a question for the UIs and wait for its answer
     # (QuestionDesk#open_question: BLOCKS until answered or cancelled).
     # @param fields [Hash] question:, options:, header:, multi_select:, allow_freeform:, …

data/lib/samagotchi/host_model.rb

@@ -78,18 +78,22 @@ module Samagotchi
     # One host's rows as the listings show them, declared ids first, then
     # the listed ones in the host's order (see Row). An id both declared and
     # listed is one row. Pure: +results+ (list_all_models') is only read.
-    # A host that errored has no rows: its declared ids aren't shown
-    # either (the listings say it's unreachable).
+    # A host that errored keeps only its declared ids, marked unavailable
+    # (still pickable; the listings warn it's unreachable); [] when it
+    # declares none.
     # @param results [Hash{String => Hash}] host name => {models: [ModelInfo], error:}
     # @param entries [Hash{String => HostRegistry::HostEntry}]
-    # @return [Hash{String => Array<Row>}] for the hosts that answered
+    # @return [Hash{String => Array<Row>}] for every host in +results+
     def self.rows(results, entries)
       results.each_with_object({}) do |(name, data), out|
-        next if data[:error]
+        declared = entries[name]&.models || {}
+        if data[:error]
+          out[name] = declared.values.map { |m| HostModel::Row.new(id: m.id, configured: true, info: nil, unavailable: true) }
+          next
+        end
 
         infos = Array(data[:models])
         by_id = infos.group_by { |info| info.id.to_s.downcase }
-        declared = entries[name]&.models || {}
         out[name] = declared.values.map do |m|
           info = by_id[m.id.downcase]&.first
           # A listed id keeps the host's spelling: a case-sensitive server takes only that.
@@ -111,6 +115,9 @@ module Samagotchi
   # A listing row (HostModel.rows): id as the host lists it, else as
   # declared;
   # configured: declared under hosts.<name>.models; info: the host's
-  # ModelInfo for it, nil when only declared.
-  HostModel::Row = Data.define(:id, :configured, :info)
+  # ModelInfo for it, nil when only declared; unavailable: the host failed
+  # to list its models; only its declared ids are shown.
+  HostModel::Row = Data.define(:id, :configured, :info, :unavailable) do
+    def initialize(id:, configured:, info:, unavailable: false) = super
+  end
 end

data/lib/samagotchi/host_registry.rb

@@ -322,7 +322,7 @@ module Samagotchi
             save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }
+            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: list_error(e) }
           end
           results_mutex.synchronize { results[name] = data }
         end
@@ -374,6 +374,11 @@ module Samagotchi
 
     private
 
+    # A listing error as text without the host's name (a provider error's
+    # #detail: "connection refused", "request failed after …"): every line
+    # that shows it names the host itself.
+    def list_error(error) = error.is_a?(LLM::ProviderError) ? error.detail : error.message
+
     # Save a host's just-listed models on disk, for the processes that spawn
     # a worker without listing (`chi send --new --model`, delegate):
     # ModelListStore is what they check an id against.

data/lib/samagotchi/llm/chat_loop.rb

@@ -510,15 +510,18 @@ module Samagotchi
           generation_controller = nil
           response = with_generation do |controller|
             generation_controller = controller
+            # One count for the step: the ask-again without thinking fields
+            # doesn't get drops of its own.
+            drops = DropCount.new(0, 0)
             begin
-              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             rescue BadRequest => e
               raise unless thinking_refused?(e)
 
               # Once per model: asked again without the thinking fields.
               @loop.thinking_refused!(@model_name)
               emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: e.detail)
-              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
             end
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
@@ -596,9 +599,14 @@ module Samagotchi
         # retries.
         MAX_STREAM_DROPS = 2
 
-        # Runs one request, asking again on a mid-stream drop. +attempt+
-        # counts the drops already retried this step.
-        def request_with_drops(iteration, retry_generation, streamed, thought, attempt, generation_controller)
+        # A step's drops asked again (+drops+) and the HTTP requests made so
+        # far (+requests+: each failed request's transport attempts), so the
+        # error that ends the step counts every request, not the last one's.
+        DropCount = Struct.new(:drops, :requests)
+
+        # Runs one request, asking again on a mid-stream drop; +count+ (a
+        # DropCount) carries on across calls for one step.
+        def request_with_drops(iteration, retry_generation, streamed, thought, count, generation_controller)
           streamed_any = false
           request(iteration, retry_generation, streamed, thought, generation_controller, -> { streamed_any = true })
         rescue RetryExhausted => e
@@ -607,10 +615,16 @@ module Samagotchi
           cancelled = [@cancel_controller, generation_controller].compact.find(&:cancelled?)
           raise RequestCancelled, cancelled.reason if cancelled
 
+          count.requests += e.attempts.to_i
           limit = @loop.stream_drop_limit(MAX_STREAM_DROPS)
-          raise if attempt >= limit || !streamed_any
+          if count.drops >= limit || !streamed_any
+            raise if count.requests == e.attempts.to_i
+
+            raise RetryExhausted.new(attempts: count.requests, last_error: e.last_error, label: e.host)
+          end
 
-          attempt += 1
+          count.drops += 1
+          attempt = count.drops
           streamed.clear
           thought.clear
           delay = @loop.generation_retry_delay(attempt)
@@ -620,6 +634,12 @@ module Samagotchi
                next_delay: delay, error_class: e.class.name, error_message: e.message, status: nil, restarted: true)
           @loop.wait_retry(delay, @cancel_controller, generation_controller)
           retry
+        rescue ProviderError => e
+          # Another failure (a 503, a refusal) after earlier requests this
+          # step: its count takes theirs in.
+          count.requests += e.attempts.to_i
+          e.attempts = count.requests
+          raise
         end
 
         # A 400 about reasoning, for a request that carried thinking fields

data/lib/samagotchi/llm/errors.rb

@@ -223,11 +223,17 @@ module Samagotchi
 
       def initialize(attempts:, last_error:, label: "llama.cpp")
         @last_error = last_error
-        super("#{label} request failed after #{attempts} attempts: #{last_error.class}: #{last_error.message}",
+        super("#{label} request failed after #{self.class.count(attempts)}: #{last_error.class}: #{last_error.message}",
               host: label, retryable: false, attempts: attempts)
       end
 
-      def summary = "network error after #{attempts} attempts (host #{host}: #{last_error.class})"
+      def summary = "network error after #{self.class.count(attempts)} (host #{host}: #{last_error.class})"
+
+      # The message without its leading "host ": "request failed after …".
+      def detail = host ? message.delete_prefix("#{host} ") : message
+
+      # "1 attempt", "3 attempts".
+      def self.count(attempts) = "#{attempts} attempt#{"s" unless attempts == 1}"
     end
 
     # A refused connection: nothing listens at the host's address. Not

data/lib/samagotchi/llm_context_strategy.rb

@@ -181,6 +181,7 @@ module Samagotchi
       return nil if session.nil?
 
       require_relative "config"
+      require_relative "model_profile"
       registry ||= begin
         require_relative "host_registry"
         HostRegistry.new

data/lib/samagotchi/model_catalog.rb

@@ -9,13 +9,14 @@ module Samagotchi
   module ModelCatalog
     # host: the host that listed (or declares) the id; ref: the name
     # `--model` takes for it (see .spell); configured: declared under
-    # hosts.<name>.models (HostModel.rows).
-    Row = Data.define(:host, :id, :ref, :configured) do
-      def initialize(host:, id:, ref:, configured: false) = super
+    # hosts.<name>.models (HostModel.rows); unavailable: a declared id of a
+    # host that failed to list its models (still pickable).
+    Row = Data.define(:host, :id, :ref, :configured, :unavailable) do
+      def initialize(host:, id:, ref:, configured: false, unavailable: false) = super
     end
     # rows: the default host's first, then the others by name, each host's
-    # declared ids first (HostModel.rows); warnings:
-    # "host: error" per host that failed.
+    # declared ids first (HostModel.rows; a host that failed keeps only
+    # those); warnings: "host: error" per host that failed.
     Listing = Data.define(:rows, :warnings)
 
     module_function
@@ -29,15 +30,13 @@ module Samagotchi
       warnings = []
       host_rows = HostModel.rows(results, registry.entries)
       results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }.each do |host|
-        if results[host][:error]
-          warnings << "#{host}: #{results[host][:error]}"
-          next
-        end
-        host_rows[host].each do |row|
+        warnings << "#{host}: #{results[host][:error]}" if results[host][:error]
+        host_rows.fetch(host, []).each do |row|
           id = row.id
           next if id.strip.empty? || (!row.configured && id.end_with?(":batch"))
 
-          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured)
+          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured,
+                          unavailable: row.unavailable)
         end
       end
       Listing.new(rows: rows, warnings: warnings)
@@ -55,7 +54,8 @@ module Samagotchi
     # go first (its rows are the "default host" group). default: the default's listed
     # row name when it resolves to one, else its resolved ref; default_typed:
     # the alias it was typed as. A row whose name resolves elsewhere (an
-    # alias named like the id shadows it) carries shadowed_by.
+    # alias named like the id shadows it) carries shadowed_by; a declared id
+    # of a host that failed to list carries unavailable.
     # @param default_name [String, nil] default.model as configured
     # @return [Hash]
     def payload(results, registry:, default_name:)
@@ -63,6 +63,7 @@ module Samagotchi
       models = listing.rows.map do |row|
         hash = { name: row.ref, host: row.host, id: row.id }
         hash[:configured] = true if row.configured
+        hash[:unavailable] = true if row.unavailable
         shadow = shadowed_by(row, registry)
         shadow ? hash.merge(shadowed_by: shadow) : hash
       end

data/lib/samagotchi/model_profile.rb

@@ -232,10 +232,11 @@ module Samagotchi
       return unknown_model_message(parsed.id, host, list.ids) if list.age < RELIST_AFTER_SECONDS
 
       fresh_ids = relist_or_nil(relist || default_relist(hosts), host, env)
-      # A re-list that answered: the saved list catches up (the default
-      # re-list, HostRegistry#list_models, saved it already).
+      # A re-list that answered: the saved list catches up. The default
+      # re-list, HostRegistry#list_models, saved it already; a given one
+      # is saved here.
       if fresh_ids
-        Samagotchi::ModelListStore.save(host, fresh_ids, env: env)
+        Samagotchi::ModelListStore.save(host, fresh_ids, env: env) if relist
         return nil if fresh_ids.any? { |id| id.to_s.casecmp?(parsed.id.to_s.strip) }
 
         return unknown_model_message(parsed.id, host, fresh_ids)

data/lib/samagotchi/models_command.rb

@@ -23,13 +23,14 @@ module Samagotchi
         Lists the models every configured host offers, as the names
         --model takes: the default first, a default-host id bare, another
         host's as host:id, then the aliases as "name -> ref". A host that
-        fails or doesn't answer in time is noted on stderr.
+        fails or doesn't answer in time is noted on stderr; the ids
+        declared under its hosts.<name>.models are still listed.
         TEXT          only the names containing it (any case)
         --format json the default, the models (host, id, name), the aliases
                       and the warnings as one JSON object
         --timeout S   wait at most S seconds for the hosts; default 4
         Exit 0 when any host listed its models, 1 when none did (the
-        default is still printed), 2 on a usage error.
+        default and declared names still print), 2 on a usage error.
     TEXT
 
     FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
@@ -59,8 +60,10 @@ module Samagotchi
       return usage_error("--timeout takes a number of seconds above 0") unless timeout&.positive?
 
       payload, listed = catalog(timeout)
+      # Before the filter: a down host's declared ids are listed even when TEXT hides them.
+      down_hosts = payload[:models].select { |m| m[:unavailable] }.map { |m| m[:host] }.uniq
       payload = filtered(payload, parsed.args.join(" ").strip)
-      options[:format] == "json" ? print_json(payload) : print_text(payload)
+      options[:format] == "json" ? print_json(payload) : print_text(payload, down_hosts)
       listed ? 0 : 1
     end
 
@@ -99,14 +102,18 @@ module Samagotchi
       @stdout.puts(JSON.generate(payload.except(:filter)))
     end
 
-    def print_text(payload)
+    # @param down_hosts [Array<String>] hosts that failed but declare ids
+    def print_text(payload, down_hosts)
       default = payload[:default]
       names = payload[:models].reject { |m| m[:shadowed_by] }.map { |m| m[:name] }
       shown_default = default && (payload[:filter].nil? || default.downcase.include?(payload[:filter].downcase))
       @stdout.puts(default) if shown_default
       (names - [default]).each { |name| @stdout.puts(name) }
       payload[:aliases].each { |a| @stdout.puts("#{a[:name]} -> #{a[:ref]}") }
-      payload[:warnings].each { |w| @stderr.puts("chi models: #{w}") }
+      payload[:warnings].each do |w|
+        kept = down_hosts.any? { |host| w.start_with?("#{host}: ") }
+        @stderr.puts("chi models: #{w}#{" (its declared ids are still listed)" if kept}")
+      end
     end
   end
 end

data/lib/samagotchi/question_desk.rb

@@ -64,6 +64,13 @@ module Samagotchi
                      "or anything else that changes files or state. Finish your reply with what you found " \
                      "and what you would do, and wait."
 
+    # The cancel reason of a question no one could answer: a
+    # --non-interactive run has no one to ask (TerminalUI).
+    UNANSWERABLE_REASON = "non_interactive"
+    UNANSWERABLE_NOTE = "No one could answer the question: this is a non-interactive run. Don't do what you " \
+                        "asked about, or anything else that changes files or state. Finish your reply with " \
+                        "what you found and what you would do."
+
     # @param session           [#call] → Session, nil
     # @param state_dir         [#call] → String, the session's state dir
     # @param emit              [#call] (event) → emits an event to the turn sink + observers
@@ -82,6 +89,8 @@ module Samagotchi
       @cv = @lock.new_cond
       @pending = nil
       @answer = nil
+      # Why the open question was cancelled (#cancel), for the sync path.
+      @cancel_reason = nil
       @sync_handler = nil
       # The standing question while it is @pending: {id:, fields:,
       # on_answer:, on_superseded_close:}; @shelved, one superseded by (or
@@ -106,7 +115,10 @@ module Samagotchi
                                     .merge(multi_select: !!payload[:multi_select], allow_freeform: !!payload[:allow_freeform]))
       # Dismissed (the card's dismiss, Esc): an answer of its own, not a
       # tool failure the model learns to avoid the tool from.
-      result = { dismissed: true, id: result[:id], note: DISMISSED_NOTE } if result.is_a?(Hash) && result[:error] == "no answer"
+      if result.is_a?(Hash) && result[:error] == "no answer"
+        note = result[:reason] == UNANSWERABLE_REASON ? UNANSWERABLE_NOTE : DISMISSED_NOTE
+        result = { dismissed: true, id: result[:id], note: note }
+      end
       # Who answered is for the relay, not the model's tool result.
       result = result.except(:by) if result.is_a?(Hash)
       result.is_a?(String) ? result : JSON.generate(result)
@@ -213,7 +225,15 @@ module Samagotchi
             emit({ type: :question_answered, id: id, answer: ans })
             return ans
           end
-          return sync_res if sync_res.is_a?(String) && !sync_res.strip.empty?
+          if sync_res.is_a?(String) && !sync_res.strip.empty?
+            # The handler's text is the answer: nothing stays pending, and
+            # every UI hears it was answered (the text as its freeform).
+            @lock.synchronize { @pending = nil }
+            clear_saved_question
+            emit({ type: :question_answered, id: id,
+                   answer: { id: id.to_s, selected: [], freeform: sync_res.strip, selected_indices: [] } })
+            return sync_res
+          end
         rescue StandardError => e
           Log.warn(:turn, "question_handler_failed", echo: "[ask_user_question] sync handler failed: #{e.message}", error: e.class.name)
         end
@@ -221,9 +241,12 @@ module Samagotchi
         # CV (no cross-thread answerer exists for synchronous UIs). Clear pending
         # and return an error so the model can fallback to plain text. Generic
         # observers will discard the stale question_requested via staleness check.
-        @lock.synchronize { @pending = nil }
+        reason = @lock.synchronize do
+          @pending = nil
+          @cancel_reason
+        end
         clear_saved_question
-        return { error: "no answer", detail: "handler failed to capture selection", id: id }
+        return { error: "no answer", detail: "handler failed to capture selection", id: id, reason: reason }.compact
       end
 
       # Block until answered/cancelled (cross-thread path: WEB/Bridge/background worker)
@@ -356,6 +379,7 @@ module Samagotchi
         next if @standing
 
         pending[:status] = "cancelled"
+        @cancel_reason = reason.to_s
         @cv.broadcast
         pending[:id]
       end
@@ -403,6 +427,7 @@ module Samagotchi
       @lock.synchronize do
         @pending = pending
         @answer = nil
+        @cancel_reason = nil
         @standing = standing&.merge(id: pending[:id])
       end
       if session

data/lib/samagotchi/served_model.rb

@@ -17,6 +17,15 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The host whose hosts.<name>.models.<id>.served names +served+ for
+    # +target+'s model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @param target [HostRegistry::ModelTarget]
+    # @return [String, nil]
+    def expected_by(target, served)
+      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+    end
+
     # The separators a provider uses when it decorates a model name: a tag
     # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
     # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else

data/lib/samagotchi/session_commands.rb

@@ -573,14 +573,14 @@ module Samagotchi
       results.keys.sort.each do |hname|
         data = results[hname]
         host_label = "#{hname} (#{data[:host]}:#{data[:port]})"
+        # Declared ids (hosts.<name>.models) first, as "(config)", never cut
+        # by MODELS_PER_HOST; a host that failed keeps only those, as
+        # "(config, host down)" under its unreachable line.
+        rows = host_rows.fetch(hname, [])
         if data[:error]
           lines << "#{host_label} — unreachable: #{data[:error]}"
-          next
-        end
-        # Declared ids (hosts.<name>.models) first, as "(config)", never cut
-        # by MODELS_PER_HOST.
-        rows = host_rows[hname]
-        if rows.empty?
+          next if rows.empty?
+        elsif rows.empty?
           lines << "#{host_label} — no models discovered"
           next
         end
@@ -599,13 +599,14 @@ module Samagotchi
         end
         next if declared.empty? && shown.empty?
 
-        lines << "#{host_label}:"
+        lines << "#{host_label}:" unless data[:error]
         hidden = needle.empty? ? [shown.size - MODELS_PER_HOST, 0].max : 0
         (declared + shown.first(shown.size - hidden)).each do |row, identifier|
           raw = row.info&.raw || {}
           raw_status = raw["status"] || raw[:status]
           status = raw_status.is_a?(Hash) ? (raw_status["value"] || raw_status[:value] || raw_status["status"] || raw_status[:status]) : raw_status
           status = ["config", status].reject { |s| s.to_s.empty? }.join(", ") if row.configured
+          status = "#{status}, host down" if row.unavailable
           base = status.to_s.empty? ? "  #{identifier}" : "  #{identifier} (#{status})"
           alias_list = (by_model[identifier.to_s.downcase] || []) + (by_model["#{hname}:#{identifier}".downcase] || [])
           alias_list.uniq!

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -96,17 +96,29 @@ module Samagotchi
         paint(TurnNote.empty_answer_line(retries), 90)
       end
 
-      # "retrying (1/3 in 0.5s): Errno::ECONNREFUSED": the retry of all the
-      # retries there will be (as the web counts), the wait before it, and
-      # what failed (generation_retrying).
+      # "↻ retrying (503) in 4.0s, 2/5": the live status while the provider
+      # is asked again (generation_retrying), worded as the web words it
+      # (turn_events.js retryStatusLine; spec/shared/labels_matrix.json):
+      # why (the HTTP status, the error's short class name, or "stream
+      # dropped" for a dropped stream's step asked again), the wait before
+      # it, and the retry of all the retries there will be.
       def format_generation_retry_line(event)
-        return "retrying (attempt #{event[:attempt]})" unless event[:max_retries]
+        why = event[:restarted] ? "stream dropped" : retry_cause(event)
+        delay = Float(event[:next_delay], exception: false)
+        text = +"\u21bb retrying"
+        text << " (#{why})" unless why.empty?
+        text << " in #{format("%.1f", (delay * 10).round / 10.0)}s" if delay&.finite?
+        text << ", #{event[:attempt]}#{"/#{event[:max_retries]}" if event[:max_retries]}" if event[:attempt]
+        text
+      end
 
-        text = "retrying (#{event[:attempt]}/#{event[:max_retries]} in #{format("%.1f", event[:next_delay].to_f)}s)"
-        # restarted: a dropped stream's step asked again (the chat loop's).
-        return "#{text}: stream dropped" if event[:restarted]
+      # What failed, for a retry line: the HTTP status, else the error's
+      # class name without its namespace (Errno::ECONNREFUSED: ECONNREFUSED).
+      def retry_cause(event)
+        status = event[:status]
+        return status.to_s unless status.nil? || status.to_s.empty? || status.to_s == "0"
 
-        event[:error_class].to_s.empty? ? text : "#{text}: #{event[:error_class]}"
+        event[:error_class].to_s.split("::").last.to_s
       end
 
       # " → image 1280×800" after a tool line whose tool read an image.
@@ -356,13 +368,16 @@ module Samagotchi
       end
 
       # /stats' cost: the reported part and the estimated one, each when present.
-      def stats_cost_text(tokens)
+      # +price_host+ names the host whose hosts.<name>.models prices the
+      # estimate came from (Engine#stats_snapshot; nil from an older worker).
+      def stats_cost_text(tokens, price_host: nil)
         reported = cost_text(tokens[:cost_sum])
         estimated = cost_text(tokens[:cost_estimate_sum], estimate: true)
         return nil if reported.empty? && estimated.empty?
         return "#{reported} (this session only)" if estimated.empty?
 
-        estimate = "#{estimated} from hosts.<name>.models prices"
+        source = price_host.to_s.empty? ? "configured prices" : "hosts.#{price_host}.models prices"
+        estimate = "#{estimated} from #{source}"
         "#{reported.empty? ? estimate : "#{reported} reported + #{estimate}"} (this session only)"
       end
 
@@ -492,7 +507,7 @@ module Samagotchi
                  "#{token_breakdown_text(tokens)}"
         speed = stats_speed_text(tokens)
         lines << "speed:            #{speed}" if speed
-        cost = stats_cost_text(tokens)
+        cost = stats_cost_text(tokens, price_host: snapshot[:price_host])
         lines << "cost:             #{cost}" if cost
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"

data/lib/samagotchi/terminal_ui.rb

@@ -1351,9 +1351,11 @@ module Samagotchi
     # question there): the question is dismissed at once, as an empty answer
     # would be, and the model finishes its reply. Never a read of stdin: a
     # pipe its writer keeps open would block it forever. Its one line goes to
-    # stderr (#banner): stdout is the answer's alone.
+    # stderr (#banner): stdout is the answer's alone. The model is told no
+    # one could answer (QuestionDesk::UNANSWERABLE_NOTE), not that the user
+    # dismissed it.
     def dismiss_unaskable_question(prompt)
-      @engine.cancel_question("user") rescue nil
+      @engine.cancel_question(QuestionDesk::UNANSWERABLE_REASON) rescue nil
       banner(prompt.summary("(dismissed: no one to answer in a non-interactive run)", paint: method(:paint)))
       false
     end

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.46.0"
+  VERSION = "0.46.1"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -24,6 +24,7 @@ require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
 require_relative "../sampling_settings"
+require_relative "../served_model"
 require_relative "../project_scope"
 require_relative "../prompt_history"
 require_relative "../version"
@@ -445,6 +446,7 @@ module Samagotchi
             listing.rows.each do |row|
               model = { name: row.host == default_host ? row.id : "#{row.host}:#{row.id}", host: row.host, id: row.id }
               model[:configured] = true if row.configured
+              model[:unavailable] = true if row.unavailable
               models << model
             end
           end
@@ -487,6 +489,33 @@ module Samagotchi
         nil
       end
 
+      # The served model a session's last generation reported (analytics.json,
+      # SessionMetrics#persist), for a session no worker runs: shown only
+      # while the name it answered is still the session's model, as
+      # Engine#served_model does, with the host whose served: expects it.
+      # {} when none applies.
+      def saved_served_model(session, persisted)
+        served = persisted["served_model"]
+        model = session.model_name.to_s
+        return {} unless served.is_a?(String) && !served.empty? && !model.empty?
+
+        registry = host_registry
+        asked = registry.bare_name(model)
+        return {} unless persisted["served_model_for"] == asked
+
+        { served_model: served, served_model_for: asked, served_expected_by: saved_served_expected_by(registry, model, served) }
+      rescue StandardError
+        {}
+      end
+
+      # See ServedModel.expected_by; nil when the model doesn't resolve (the
+      # mismatch still shows).
+      def saved_served_expected_by(registry, model, served)
+        ServedModel.expected_by(registry.resolve(model), served)
+      rescue StandardError
+        nil
+      end
+
       # A session's LLM context strategy, apply rule and budget, each with
       # where it came from (LLMContextStrategy::Explained#summary), as its
       # worker would resolve them; nil when they can't be.
@@ -657,18 +686,22 @@ module Samagotchi
         # A /model in the worker changes it before the file catches up.
         session.model_name = snapshot["model_name"] if snapshot && !snapshot["model_name"].to_s.empty?
         session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
-        # What the worker's server said it served for that model (after a turn).
+        # What the worker's server said it served for that model (after a turn);
+        # without a worker, what the session's analytics.json last saved.
+        persisted = snapshot ? nil : read_analytics(id)
         if snapshot
           session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"],
                                             served_expected_by: snapshot["served_expected_by"])
           # The model notes its prompt carries now (a /model there changes them).
           session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
+        else
+          session_json = session_json.merge(saved_served_model(session, persisted))
         end
         # The LLM context strategy the next turn runs under (the info bar's
         # chip): the worker's, else worked out here from the session file.
         session_json = session_json.merge(llm_context: (snapshot && snapshot["llm_context"]) || llm_context_for(session))
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
-        timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"])
+        timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {
           session: session_json,
           history: read_history(id),
@@ -1502,8 +1535,9 @@ module Samagotchi
 
       # The whole timing: analytics.json's records merged with a live
       # worker's (by id), and turn_count, the finished turns (#turn_count).
-      def timing_payload(session_id, live_metrics: nil)
-        persisted = read_analytics(session_id)
+      # +persisted+: the session's analytics.json when the caller read it.
+      def timing_payload(session_id, live_metrics: nil, persisted: nil)
+        persisted ||= read_analytics(session_id)
         live = live_metrics.is_a?(Hash)
         source = if live
                    persisted.merge(live_metrics).merge(

data/lib/samagotchi/web/public/index.html

@@ -494,6 +494,7 @@ body.has-session #composer .actions-col{flex-wrap:nowrap;flex-shrink:0}
 #composer .actions-col .model-pick:hover,#composer .actions-col .model-pick[aria-expanded="true"]{filter:none;background:color-mix(in srgb,var(--bg-hover) 75%,transparent);color:var(--text-2)}
 #composer .actions-col .model-pick[hidden],body.has-session #composer .actions-col .model-pick{display:none}
 .model-pick-name{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#composer .actions-col .model-pick.unavailable .model-pick-name{color:var(--text-faint)}
 .model-pick::after{content:"";position:absolute;right:9px;top:50%;width:5px;height:5px;border-right:1.5px solid currentColor;border-bottom:1.5px solid currentColor;transform:translateY(-70%) rotate(45deg);pointer-events:none;transition:transform .12s ease}
 .model-pick[aria-expanded="true"]::after{transform:translateY(-20%) rotate(225deg)}
 @media(max-width:600px){#composer .actions-col .model-pick{max-width:60%}}
@@ -529,6 +530,8 @@ body.has-session #composer .actions-col{flex-wrap:nowrap;flex-shrink:0}
 #modelList mark{background:none;color:var(--accent);font-weight:600}
 #modelList .model-option.chosen mark{color:var(--text-bright)}
 #modelList .model-note{flex:none;font-size:11px;color:var(--text-faint)}
+#modelList .model-option.unavailable:not(.chosen) .model-id,#modelList .model-option.unavailable .model-host{color:var(--text-faint)}
+#modelList .model-option.unavailable .model-note{color:var(--warn-text)}
 #modelList .model-empty{padding:10px;font-size:13px;color:var(--text-faint)}
 @media(max-width:600px){#modelPanel{left:6px;width:calc(100% - 12px)}#modelSearch{font-size:16px}#modelList .model-option{padding-top:8px;padding-bottom:8px}}
 /* The / autocomplete: a list over the composer card's top edge. It wears the glass edge and shadow, but opaque:

data/lib/samagotchi/web/public/model_pick.js

@@ -2,16 +2,19 @@
 
 export const MODEL_KEY = "chi_model";
 
-// The name to preselect: the remembered one when it is still offered (any
-// case), else the server's default, else the first offered, else "".
-export function pickModel(names, defaultName, stored) {
+// The name to preselect from the rows (modelRows): the remembered one when
+// it is still offered (any case), else the server's default, both even
+// when their host is down; else the first row whose host answered, else
+// the first row, else "".
+export function pickModel(rows, defaultName, stored) {
+  const names = rows.map((r) => r.name);
   const want = String(stored || "").trim().toLowerCase();
   if (want) {
     const kept = names.find((n) => n.toLowerCase() === want);
     if (kept) return kept;
   }
   if (defaultName && names.includes(defaultName)) return defaultName;
-  return defaultName || names[0] || "";
+  return defaultName || (rows.find((r) => !r.unavailable) || rows[0])?.name || "";
 }
 
 
@@ -21,7 +24,8 @@ export const RECENT_KEY = "chi_model_recent";
 // sampling (the configured request parameters as /model words them) when
 // the model has some, and llm_context (the LLM context it starts under,
 // LLMContextStrategy::Explained#summary) when the server sent one, and
-// configured when the host declares the id (hosts.<name>.models). The
+// configured when the host declares the id (hosts.<name>.models), and
+// unavailable when that host failed to list its models. The
 // default host's names are bare (name == id); the server's own default,
 // unshifted when no host lists it, has no host and goes with them, shown
 // by its name.
@@ -36,6 +40,7 @@ export function modelRows(payload) {
       const row = { name, host, id, isDefaultHost: !host || name === id };
       if (m.sampling) row.sampling = String(m.sampling);
       if (m.configured === true) row.configured = true;
+      if (m.unavailable === true) row.unavailable = true;
       if (m.llm_context && typeof m.llm_context === "object") row.llm_context = m.llm_context;
       return row;
     });
@@ -44,9 +49,9 @@ export function modelRows(payload) {
 const byId = (a, b) => (b.configured === true) - (a.configured === true) ||
   a.id.localeCompare(b.id, "en", { sensitivity: "base" });
 
-// The rows under their hosts, [{host, isDefault, rows}]: the default host
-// first, the others in the server's order; inside a host the configured
-// ids first, each part A-Z.
+// The rows under their hosts, [{host, isDefault, unavailable, rows}]: the
+// default host first, the others in the server's order; inside a host the
+// configured ids first, each part A-Z. unavailable: every row's host is down.
 export function groupRows(rows) {
   const groups = [];
   const find = (key) => groups.find((g) => g.key === key);
@@ -61,23 +66,25 @@ export function groupRows(rows) {
     group.rows.push(row);
   }
   return groups.map(({ host, isDefault, rows: rs }) => ({
-    host: host || "default", isDefault, rows: [...rs].sort(byId),
+    host: host || "default", isDefault, unavailable: rs.every((r) => r.unavailable === true), rows: [...rs].sort(byId),
   }));
 }
 
-// The word after a row's id: "default" for the default model, else
-// "config" for an id the host declares (hosts.<name>.models), else "".
+// The words after a row's id: "default" for the default model, else
+// "config" for an id the host declares (hosts.<name>.models), else "";
+// then "host down" when its host failed to list its models.
 export function rowNote(row, defaultName) {
-  if (row.name === defaultName) return "default";
-  return row.configured ? "config" : "";
+  const word = row.name === defaultName ? "default" : row.configured ? "config" : "";
+  return [word, row.unavailable ? "host down" : ""].filter(Boolean).join(" · ");
 }
 
-// A row's tooltip: its configured sampling, and where a configured id
-// comes from; "" when neither.
+// A row's tooltip: its configured sampling, where a configured id comes
+// from, and that its host is down; "" when none.
 export function rowTitle(row) {
   const parts = [];
   if (row.sampling) parts.push(`sampling: ${row.sampling}`);
   if (row.configured) parts.push(`served by config (hosts.${row.host}.models)`);
+  if (row.unavailable) parts.push(`host ${row.host} didn't list its models (down?); a chat on it may fail`);
   return parts.join("; ");
 }
 

data/lib/samagotchi/web/public/model_picker.js

@@ -50,16 +50,19 @@ export function createModelPicker({ button, panel, input, list, composer, center
 
   const isOpen = () => !panel.hidden;
 
+  // Greyed while the chosen row's host is down (the button's tooltip,
+  // app.js', carries the host's warning).
   function setChosen(name) {
     chosen = name;
     button.querySelector(".model-pick-name").textContent = name;
+    button.classList.toggle("unavailable", rows.some((r) => r.name === name && r.unavailable === true));
   }
 
   function rowHtml(row, i, { hostMarks = [], idMarks = [], showHost = !row.isDefaultHost } = {}) {
     const host = showHost ? `<span class="model-host">${markedHtml(row.host, hostMarks)}</span><span class="model-dot"> · </span>` : "";
     const noteText = rowNote(row, defaultName);
     const note = noteText ? `<span class="model-note">${noteText}</span>` : "";
-    const cls = `model-option${i === active ? " active" : ""}${row.name === chosen ? " chosen" : ""}`;
+    const cls = `model-option${i === active ? " active" : ""}${row.name === chosen ? " chosen" : ""}${row.unavailable ? " unavailable" : ""}`;
     const titleText = rowTitle(row);
     const title = titleText ? ` title="${escapeHtml(titleText)}"` : "";
     return `<div class="${cls}" role="option" id="model-option-${i}" aria-selected="${i === active}" data-index="${i}"${title}>` +
@@ -83,7 +86,7 @@ export function createModelPicker({ button, panel, input, list, composer, center
         recent.forEach((row) => add(row));
       }
       for (const group of groupRows(rows)) {
-        html += head(group.host, group.isDefault ? "default host" : "");
+        html += head(group.host, [group.isDefault ? "default host" : "", group.unavailable ? "host down" : ""].filter(Boolean).join(" · "));
         group.rows.forEach((row) => add(row, { showHost: false }));
       }
     }
@@ -217,7 +220,7 @@ export function createModelPicker({ button, panel, input, list, composer, center
       close();
       rows = next;
       defaultName = String(payload.default || "");
-      setChosen(pickModel(rows.map((r) => r.name), payload.default, stored || chosen));
+      setChosen(pickModel(rows, payload.default, stored || chosen));
       return true;
     },
     chosen: () => chosen,

data/lib/samagotchi/web/public/question_card.js

@@ -25,6 +25,13 @@ const CONTINUE_CLOSED = {
   replaced: "Asked again",
 };
 
+// A close reason that reads as words on any card, not as "(reason)": a
+// question asked in a --non-interactive run (QuestionDesk's
+// UNANSWERABLE_REASON) had no one to answer it.
+const CLOSED_PLAIN = {
+  non_interactive: "No one could answer (non-interactive run)",
+};
+
 // A delegate's approval relayed to this session's user (the approval
 // relay): who asks (the chain, "ab12 → cd34" for a grandchild's) and its
 // task, or null.
@@ -97,6 +104,7 @@ function relayClosedText(relay, reason) {
 export function resultText(pq, { answer = null, cancelled = false, reason = "" } = {}) {
   const approval = isApproval(pq);
   const relay = relayView(pq);
+  if (cancelled && Object.hasOwn(CLOSED_PLAIN, reason)) return CLOSED_PLAIN[reason];
   if (cancelled && relay && reason !== "dismissed") return relayClosedText(relay, reason);
   if (isContinue(pq)) return continueResultText({ answer, cancelled, reason });
   if (cancelled) {

data/lib/samagotchi/web/public/turn_events.js

@@ -208,12 +208,16 @@ export function noticeLine(entry = {}) {
 }
 
 // The live turn's status while the provider is asked again after an error
-// (generation_retrying): "↻ retrying (503) in 4 s, 2/5" (retry 2 of 5).
+// (generation_retrying): "↻ retrying (503) in 4.0s, 2/5" (retry 2 of 5).
+// The TUI words it the same (Formatting#format_generation_retry_line;
+// spec/shared/labels_matrix.json).
 export function retryStatusLine({ attempt, max_retries, next_delay, status, error_class, restarted } = {}) {
   // restarted: a dropped stream's step asked again (the chat loop's).
   const why = restarted ? "stream dropped" : status || String(error_class || "").split("::").pop();
-  const delay = Number(next_delay);
-  const when = Number.isFinite(delay) ? ` in ${delay < 1 ? delay.toFixed(1) : Math.round(delay)} s` : "";
+  // null/"" are no delay (Number would make them 0).
+  const delay = next_delay === null || next_delay === "" ? NaN : Number(next_delay);
+  // Rounded as Ruby's Float#round does (half away from zero), then one decimal.
+  const when = Number.isFinite(delay) ? ` in ${(Math.round(delay * 10) / 10).toFixed(1)}s` : "";
   const count = attempt ? `, ${attempt}${max_retries ? `/${max_retries}` : ""}` : "";
   return `↻ retrying${why ? ` (${why})` : ""}${when}${count}`;
 }

data/lib/samagotchi/worker.rb

@@ -850,14 +850,18 @@ module Samagotchi
     # start only, so the reports its loop merged are not in the
     # conversation: their rings stay for the next turn, even when the turn
     # itself stays (a reminder or continue turn). Not one raised after the
-    # turn ended (the Engine's post-turn work): the turn was kept as
-    # completed, the reports in it.
+    # turn ended (the Engine's post-turn work): the turn was kept as it
+    # ended, completed or canceled, the reports in it (a turn TurnFlow
+    # takes back is a restore, above).
     def merges_lost?(error)
       return false if error.nil? || error.is_a?(LLM::FailedTurn)
 
-      @session.last_turn&.dig("outcome") != "completed"
+      !KEPT_TURN_OUTCOMES.include?(@session.last_turn&.dig("outcome"))
     end
 
+    # The Engine's turn endings that keep the turn's conversation (#merges_lost?).
+    KEPT_TURN_OUTCOMES = %w[completed canceled].freeze
+
     # A delegate child's turn that was its parent's (#reports_to_parent?)
     # rings the parent, after the save: the parent reads a settled child.
     # A question it rang about that still waits makes the next turn ring

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.46.0
+  version: 0.46.1
 platform: ruby
 authors:
 - Dmitry Dedov