samagotchi 0.54.0 → 0.56.0

data/docs/sessions.md

@@ -68,9 +68,9 @@ 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)`; 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 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). A file in a tool row (a read, edit or write's title) and its diff lines are refs: hover one and click to open the current file in your editor at that line, on this machine only (`web.editor`; the browser's "always allow" for the page's port and VS Code's "allow opening local files" are asked once; see [Opening files from chi web](configuration.md#opening-files-from-chi-web)). 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. Its `think` chip does the same for the thinking level (`/thinking`), and on a chat host its `reasoning` chip for the reasoning history (`reasoning all · session`, `/reasoning-history`; `session.reasoning_history`, null on a native host). A `/thinking` or `/reasoning-history` change that restarts the prompt cache asks first: the reply bubble has an **Apply (restarts the cache)** button that sends its `--yes` line (the chips' Set sends that line itself; see [Changes that restart the prompt cache](configuration.md#changes-that-restart-the-prompt-cache)). 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), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `day N` chip and rows, the info bar's ← → links, a refused continue), `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`).
+- 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), `chains.js` (session chains: the links from `continues`, the cards folded into the latest link's, its `day N` chip and rows, the info bar's ← → links, a refused continue), `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), `commands.js` (session commands: which composer lines are commands, the page's own replies, a `command_ran`'s bubble, the page's command bubbles kept across a re-read), `composer.js` (where a composer line goes, `routeComposerLine`: /cut and /queue, the start page's own replies, a session command or `!cmd`, a typo hint, else a turn; and a session command sent from the composer or a chip), `restore.js` (a failed turn's prompt handed back into this tab's composer, before or after its `/turn` ack), `lists_view.js` (the session lists: the strip and its pill, all sessions with its search, count and select mode, their cards, the family and chain popovers; the cards, tile and pill as lit-html templates, drawn as new nodes each time, and the lists' orders as pure functions), `stream_handlers.js` (the open session's stream event handlers, by event type, over the page's views and hooks; a snapshot replays through them too), `info_bar.js` (the session bar's info line as a lit-html template over a plain model: id, status, model, chain links, chips, ctx, speed, clock, worker badge), `session_state.js` (what the page knows about the open session: its empty state, and `sessionStateFrom`, the fields a `GET /sessions/:id` payload sets), `refs.js` (refs: a kind and a target on the element, the actions per kind, one delegated click). 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).
 
 **Test-session hygiene:**

data/docs/testing.md

@@ -15,12 +15,32 @@ bug) or a broken spec: fix it, or disable that line with the reason (`# rubocop:
 No spec reads your own setup. The suite points `XDG_CONFIG_HOME` and `XDG_STATE_HOME` at temp folders,
 clears your `SAMAGOTCHI_*` environment, and keeps every spec off the network (WebMock).
 
-The web specs run in plain node. One that renders with lit-html (`turn_view.js`, `thinking_chip.js`,
-`vendor/lit-html.js`) needs a DOM: `import "./dom_shim.js";` as its first import (happy-dom, a devDependency only,
-never shipped; about 0.3 s per spec file that loads it). The shim's `htmlOf(nodes)` and `canon(html)` compare markup
+The web specs run in plain node. One that loads lit-html (`turn_view.js`, `thinking_chip.js`, `llm_context_chip.js`,
+`info_bar.js`, `lists_view.js`, `vendor/lit-html.js`) needs a DOM: `import "./dom_shim.js";` as its first import (happy-dom, a
+devDependency only, never shipped; about 0.3 s per spec file that loads it). The shim's `htmlOf(nodes)` and `canon(html)` compare markup
 without lit's marker comments. happy-dom 20 picks the wrong option of a `<select>` whose options lit inserted with
 `?selected`: read the option marked `selected` (`option[selected]`), not `select.value`; the browser follows the mark.
 
+## While you work: affected specs
+
+```sh
+script/affected-specs                 # the specs for this branch's change, best first, at most 10
+bundle exec rspec $(script/affected-specs)
+script/affected-specs --why           # with the reason for each pick; --all: no cap; --run: runs them
+script/affected-specs A..B            # another range (A...B: from their merge-base); a single REV: vs the working tree
+```
+
+A builder runs these while working, not the full suite: the specs the change touched, the specs named after the
+files it changed (`lib/samagotchi/foo/bar.rb` → `spec/foo/bar_spec.rb`, `bar_*_spec.rb`…), the specs that read
+docs or source as text (its `RULES`: add one when a full run catches what the names missed), then the specs that
+name a changed file's class. The default range is the merge-base with main (or origin/main) plus uncommitted and untracked files.
+The Ruby specs go to stdout; the node tests to run (`npm test` targets), "web changed: also run npm run e2e" and a
+hint for a hub class (named in too many specs to list) go to stderr. Nothing printed means nothing matched.
+
+It finds a change's own specs, not the regressions it causes elsewhere. So before committing, run the full suite
+(`bundle exec parallel_rspec -n 8`), unless your task says the coordinator runs it; the coordinator runs it at merge
+either way.
+
 ## Worktrees
 
 Each fix or feature gets its own worktree next to the main checkout:

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -3,6 +3,7 @@
 require_relative "../events"
 require_relative "../kernel_loop"
 require_relative "../steer"
+require_relative "../tool_row_fields"
 require_relative "turn_notice"
 
 module Samagotchi
@@ -158,9 +159,10 @@ module Samagotchi
       def self.tool_replay_events(part)
         call = { iteration: part[:iteration], call_index: part[:call_index], tool: part[:tool] }
         call[:label] = part[:label] if part[:label]
-        # Its title and, for an alias's call, the name the model used.
-        title = part.slice(:title, :called_as).compact
-        view = part[:view] ? { view: part[:view] } : {}
+        # Its row fields (ToolRowFields), each in its place: title and, for
+        # an alias's call, the name the model used, also in the activity.
+        title = part.slice(*ToolRowFields::ACTIVITY_KEYS).compact
+        view = part.slice(*ToolRowFields::EVENT_KEYS).compact
         events = [{ type: :tool_call_started, **call, params: part[:params], **title, **view }]
         if part[:status] == "running"
           events.first[:elapsed_ms] = part[:elapsed_ms] unless part[:elapsed_ms].nil?
@@ -275,9 +277,7 @@ module Samagotchi
           part = { kind: "tool", iteration: event[:iteration], call_index: event[:call_index],
                    tool: event[:tool], params: event[:params], status: "running" }
           part[:label] = event[:label] if event[:label]
-          part[:title] = event[:title] if event[:title]
-          part[:called_as] = event[:called_as] if event[:called_as]
-          part[:view] = event[:view] if event[:view]
+          ToolRowFields::KEYS.each { |key| part[key] = event[key] if event[key] }
           parts << part
           @tool_started_at[[event[:iteration], event[:call_index]]] = @clock.call
         when :tool_call_completed

data/lib/samagotchi/bundles/system/config_modification_protocol.md

@@ -58,7 +58,7 @@ Only the nested form is read. An env name used as a top-level key (`SAMAGOTCHI_D
 
 - `model_aliases:` map of alias → model id (`ModelRef.parse`, through `HostRegistry#resolve`). Keys lowercased on write (`ConfigFile.write_model_alias!`). Values may be bare `model` or qualified `host:model` (hybrid; only `:` names a host, `org/model` is an id). Aliases apply once: never point an alias at another alias.
 - `hosts:` map of `name → {host, port | url, transport, api, api_key_env, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; workers inherit via `SAMAGOTCHI_HOSTS_JSON` (`hosts_json_for_env`, `session_manager.rb`).
-- `models:` map of model id or alias → `{profile, vision, sampling, thinking}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
+- `models:` map of model id or alias → `{profile, vision, sampling, thinking, reasoning_history}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `reasoning_history:` (here or on a host) is `drop|turn|all`, which of its reasoning a chat host's model gets back. Precedence: the session's own level (`/reasoning-history LEVEL`, saved in the session) > `SAMAGOTCHI_REASONING_HISTORY` > `models:` > `hosts.<name>.reasoning_history` > `turn`; `docs/configuration.md` "Reasoning history". `/thinking` and `/reasoning-history` ask before a change that restarts the prompt cache; `--yes` applies it (`chi send` commands apply directly). `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
 - `hooks:` map of `hooks_dir` + per-event lists `{path, on_error}` (`Hooks::Loader.load`). `hooks_dir` may start with `~`.
 - `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_approvals` (`off`, the default: a parent agent's `chi answer` can only deny an approval; `once`: it may give "Allow once" too; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.
 

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.54.0
+version: 0.56.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
   self_map.md: sha256:dfc19266259a9af1e0d769b7e0f67996b740b0c9921fdf3dadad973f6e5c144a
-  config_modification_protocol.md: sha256:45064ac6b19863e1646d15891d0e9cc7a8f10ab981a0d25d6e13891591538b8a
+  config_modification_protocol.md: sha256:d908921b5988244fb2a03fe04e693d0e7a1dfadf8cd77704e9232826db7eb2d7
   memory_guide.md: sha256:15cd3b24eda853cc458371c6c75809a2d4b5352311d075aaa4384926b5221c27
   delegated.md: sha256:aedaa1e756a244904c5560fff0424e06fb468bbdcb0358bccefe321d67cd2614

data/lib/samagotchi/cache_confirm.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The confirm step before a session setting change that restarts the
+  # prompt cache (/thinking, /reasoning-history): such a change, sent
+  # without --yes from a person at a web tab or a chi TUI, changes nothing
+  # and replies with what it costs and the line that applies it. Two steps,
+  # no stored state: the reply carries a Confirm (SessionCommands::Result,
+  # the worker's command_ran), the TUI prefills its line, the web draws an
+  # Apply button that sends it.
+  module CacheConfirm
+    YES_FLAGS = %w[--yes -y].freeze
+    # The costs worth asking about (Thinking.cache_cost,
+    # ReasoningHistory.cache_cost); :tail and nil are not.
+    COSTLY = %i[full provider history].freeze
+
+    # The line that applies a change, and the question the reply ends with.
+    Confirm = Data.define(:line, :text) do
+      # The plain form the worker's command_ran carries.
+      # @return [Hash] symbol keys
+      def to_h = { line: line, text: text }
+    end
+
+    module_function
+
+    # A command's argument words with --yes / -y (anywhere) taken out.
+    # @param args [String] what follows the command name
+    # @return [Array(String, Boolean)] the rest, stripped and downcased, and
+    #   whether --yes was there
+    def split(args)
+      words = args.to_s.strip.downcase.split
+      yes = words.any? { |word| YES_FLAGS.include?(word) }
+      [(words - YES_FLAGS).join(" "), yes]
+    end
+
+    # Whether a change must ask first: the effective level changes, the
+    # cost is one of COSTLY, and the session has a model reply (a cache to
+    # restart at all).
+    def needed?(cost:, history:, changed:)
+      changed && history && COSTLY.include?(cost)
+    end
+
+    # The Confirm for +name+ set to +word+: the line with --yes, and the
+    # question naming it.
+    # @return [Confirm]
+    def confirm(name, word)
+      line = "#{name} #{word} --yes"
+      Confirm.new(line: line, text: "Nothing changed yet: send `#{line}` to apply.")
+    end
+  end
+end

data/lib/samagotchi/client_id.rb

@@ -39,8 +39,20 @@ module Samagotchi
     HUMAN_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
     HUMAN_IDS = [CLI_SEND].freeze
 
+    # A person at a screen that shows a command's reply and can answer it
+    # (#interactive?): a web tab, an attached chi TUI.
+    INTERACTIVE_PREFIXES = [WEB_PREFIX, TUI_PREFIX].freeze
+
     module_function
 
+    # Whether +client_id+ is a web tab or a chi TUI, which see a command's
+    # reply and can send the line it asks for (CacheConfirm); chi send, a
+    # delegate, a plugin, chi itself and nil are not.
+    def interactive?(client_id)
+      id = client_id.to_s
+      INTERACTIVE_PREFIXES.any? { |prefix| id.start_with?(prefix) }
+    end
+
     # Whether +client_id+ (a turn's or a line's origin) is a human's input.
     def human?(client_id)
       return true if client_id.nil?

data/lib/samagotchi/config.rb

@@ -187,6 +187,10 @@ module Samagotchi
       # is bin/chi's own --thinking; models: and hosts: entries rank below
       # the flag and the env, above config.yml's value.
       Entry.new(key: "thinking.level",           yaml_path: %w[thinking level],           type: :string, default: "default",       expose: %i[env config]),
+      # Which of its reasoning a chat host's model gets back (ReasoningHistory):
+      # the environment only, for A/B runs; models: and hosts: entries are
+      # the config surface.
+      Entry.new(key: "reasoning_history",        yaml_path: %w[reasoning_history],        type: :string, default: nil,              expose: %i[env]),
 
       Entry.new(key: "default.max_tokens",       yaml_path: %w[default max_tokens],       type: :integer, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "max_tool_output_chars",    yaml_path: %w[max_tool_output_chars],    type: :integer, default: 10_000,          expose: %i[env config cli]),
@@ -250,6 +254,8 @@ module Samagotchi
       Entry.new(key: "web.view",                 yaml_path: %w[web view],                 type: :enum,    default: "stage",        expose: %i[env config cli], enum_values: %w[stage turn]),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli]),
+      # What a file ref (a tool row's file, a diff line) opens on this machine: a preset (vscode, vscode-insiders, cursor, zed, none) or a URL template with {path} and an optional {line} (Web::Editor).
+      Entry.new(key: "web.editor",               yaml_path: %w[web editor],               type: :string, default: "vscode",        expose: %i[env config cli]),
 
       Entry.new(key: "no_interrupt",             yaml_path: %w[no_interrupt],             type: :bool,   default: false,            expose: %i[env config cli]),
       Entry.new(key: "no_default_input",         yaml_path: %w[no_default_input],         type: :bool,   default: false,            expose: %i[env config cli]),
@@ -267,9 +273,9 @@ module Samagotchi
     # Maps of named entries and the keys an entry may hold
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
-      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
-                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
-      "models" => %w[profile vision sampling thinking window_tokens llm_context_strategy llm_context_apply
+      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking
+                    reasoning_history enabled remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
+      "models" => %w[profile vision sampling thinking reasoning_history window_tokens llm_context_strategy llm_context_apply
                      llm_context_budget_tokens].freeze
     }.freeze
     # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).

data/lib/samagotchi/engine.rb

@@ -62,6 +62,7 @@ require_relative "vision_context"
 require_relative "vision_support"
 require_relative "sampling_settings"
 require_relative "thinking"
+require_relative "reasoning_history"
 require_relative "answer_display"
 require_relative "edit_preview"
 require_relative "question_desk"
@@ -1010,7 +1011,8 @@ 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,
-                                thinking: thinking_explained&.summary, prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
+                                thinking: thinking_explained&.summary,
+                                reasoning_history: reasoning_history_explained&.summary, 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
@@ -1093,16 +1095,80 @@ module Samagotchi
     end
 
     # The effective model's thinking level with where it came from and the
-    # session's own (Thinking::Explained), as the next turn resolves it;
+    # session's own (SettingExplained), as the next turn resolves it;
     # nil when it can't be resolved.
-    # @return [Thinking::Explained, nil]
-    def thinking_explained
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; /thinking asks what a change would resolve to).
+    def thinking_explained(own: thinking_override)
       target = @host_registry.resolve(@effective_model_name)
-      Thinking.explain(target, names: model_lookup_names(target), session: thinking_override)
+      Thinking.explain(target, names: model_lookup_names(target), session: own)
     rescue StandardError
       nil
     end
 
+    # "drop (models: qwen)" for /model: the effective chat model's
+    # reasoning_history level and where it came from; nil when it is the
+    # default, the model runs on the native loop (which ignores it) or it
+    # can't be resolved.
+    def reasoning_history_summary
+      target = @host_registry.resolve(@effective_model_name)
+      return nil unless target.entry&.chat?
+
+      level, source = ReasoningHistory.resolve(target, names: model_lookup_names(target),
+                                                       session: reasoning_history_override)
+      source ? ReasoningHistory.label(level, source) : nil
+    rescue StandardError
+      nil
+    end
+
+    # The effective chat model's reasoning_history level with where it came
+    # from and the session's own (SettingExplained), as the next turn
+    # resolves it; nil on a native host (the native loop ignores it; native:
+    # true resolves it there too, for /reasoning-history) or when it can't
+    # be resolved.
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; a command asks what a change would resolve to).
+    def reasoning_history_explained(native: false, own: reasoning_history_override)
+      target = @host_registry.resolve(@effective_model_name)
+      return nil unless native || target.entry&.chat?
+
+      ReasoningHistory.explain(target, names: model_lookup_names(target), session: own)
+    rescue StandardError
+      nil
+    end
+
+    # What a reasoning_history change from level +from+ to level +to+ costs
+    # the effective model's prompt cache, given the session's conversation
+    # (ReasoningHistory.cache_cost): :history or nil. A host ChatLoop
+    # marked as refusing it may still get :history (one needless ask).
+    # @return [Symbol, nil]
+    def reasoning_history_cache_cost(from, to)
+      target = @host_registry.resolve(@effective_model_name)
+      ReasoningHistory.cache_cost(from, to, target: target, conversation: @session&.messages)
+    rescue StandardError
+      nil
+    end
+
+    # Whether the session has a model reply (a cache to restart at all).
+    def history?
+      Array(@session&.messages).any? { |entry| entry[:role].to_s == "model" }
+    end
+
+    # The session's own reasoning_history level, nil when it has none.
+    # @return [Symbol, nil]
+    def reasoning_history_override = @session&.reasoning_history
+
+    # Set the session's own reasoning_history level (nil unsets it); the
+    # next turn's start resolves it. The caller saves the session.
+    # @raise [ArgumentError] with no session yet
+    def reasoning_history_override=(level)
+      raise ArgumentError, "no session yet" unless @session
+
+      @session.reasoning_history = level
+    end
+
     # The session's own thinking level, nil when it has none.
     # @return [Symbol, nil]
     def thinking_override = @session&.thinking
@@ -1192,6 +1258,7 @@ module Samagotchi
         context_status: @last_context_status&.dup || saved_context_status(metrics[:context]),
         llm_context: llm_context_summary,
         thinking: thinking_explained&.summary,
+        reasoning_history: reasoning_history_explained&.summary,
         recap_enabled: !@recap.nil?,
         recap_min_user_turns: @recap&.min_user_turns,
         recap_inactivity_seconds: @recap&.inactivity&.to_i
@@ -1926,7 +1993,8 @@ module Samagotchi
       thinking_target = @host_registry.resolve(@effective_model_name)
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
-      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
+      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first,
+                            reasoning_history: reasoning_history_level(thinking_target), model_name: nil,
                             window_setting: nil, llm_context: nil, price: nil)
     end
     private :turn_settings
@@ -2317,6 +2385,23 @@ module Samagotchi
       nil
     end
 
+    # The host refused the model's reasoning sent back (reasoning_history)
+    # and the chat loop asked the step again without it, as it will from
+    # now on: logged, and said once per session and host.
+    def reasoning_history_refused(event)
+      _level, target = @turn_thinking
+      return unless target
+
+      Log.warn(:model, "reasoning_history_refused", level: event[:level], host: target.entry.name, model: event[:model],
+                                                    detail: event[:detail])
+      return unless (@thinking_notices ||= Set.new).add?([@session&.id, target.entry.name, :reasoning_history_refused])
+
+      hook_notify("#{target.entry.name} refused reasoning sent back (reasoning_history: #{event[:level]}) for " \
+                  "#{event[:model]} (#{event[:detail]}); sent without it from now on", :warn, "reasoning history")
+    rescue StandardError
+      nil
+    end
+
     def thinking_notice_once(kind, target, level, text)
       key = [@session&.id, target.entry.name, kind]
       return unless (@thinking_notices ||= Set.new).add?(key)
@@ -2324,6 +2409,14 @@ module Samagotchi
       hook_notify(text, level, "thinking")
     end
 
+    # +target+'s ReasoningHistory level, the session's own first; the
+    # default when it can't be resolved.
+    def reasoning_history_level(target)
+      ReasoningHistory.resolve(target, names: model_lookup_names(target), session: reasoning_history_override).first
+    rescue StandardError
+      ReasoningHistory::DEFAULT
+    end
+
     # +target+'s thinking level (Thinking.resolve), the session's own first.
     def thinking_level(target)
       Thinking.resolve(target, names: model_lookup_names(target), session: thinking_override).first
@@ -2602,9 +2695,10 @@ module Samagotchi
           end
         when :generation_chunk then note_generation_thought(progress[:thinking])
         end
-        # The chat loop asked again without the thinking fields: a notice,
-        # not an event of its own.
+        # The chat loop asked again without the thinking fields or the
+        # reasoning sent back: a notice, not an event of its own.
         next thinking_refused(event) if event[:type] == :thinking_refused
+        next reasoning_history_refused(event) if event[:type] == :reasoning_history_refused
 
         event = with_generation_report(event) if event[:type] == :generation_completed
         emit_event(on_event, event)

data/lib/samagotchi/engine_peers.rb

@@ -18,6 +18,7 @@ module Samagotchi
       def relay = engine.relay_peer
       def model_ref = engine.effective_model_ref
       def thinking = engine.thinking_override
+      def reasoning_history = engine.reasoning_history_override
     end
 
     # What the approval relay needs from the parent's Engine (Peers#relay):

data/lib/samagotchi/file_ref.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "tools/read"
+require_relative "tools/write"
+require_relative "tools/edit"
+
+module Samagotchi
+  # A ref to the file a read/write/edit call touched, for a UI to trace it
+  # (the web opens it in this machine's editor): its absolute path (the
+  # call's path against the session's cwd) and the lines the call named (a
+  # range read or a range edit). A ref is a kind and a target; what a click
+  # does is the UI's (refs.js keeps the actions per kind), so nothing here
+  # names an editor.
+  FileRef = Data.define(:path, :line, :end_line) do
+    # @return [Hash] {kind: "file", path:, line:, end_line:}, the lines only
+    #   when there are some
+    def to_h = { kind: FileRef::KIND, **super.compact }
+  end
+
+  class FileRef
+    KIND = "file"
+
+    TOOLS = [Tools::Read::NAME, Tools::Write::NAME, Tools::Edit::NAME].freeze
+
+    # @param cwd [String, nil] the session's working directory; without one
+    #   a relative path gets no ref (an absolute or ~ path still does)
+    # @return [FileRef, nil] nil for a tool that isn't a file tool and for a
+    #   path it can't place. +line+: the call's start_line when positive;
+    #   +end_line+: its end_line, only when past +line+.
+    def self.for(tool_name, call, cwd:)
+      return nil unless TOOLS.include?(tool_name) && call.is_a?(Hash)
+
+      path = absolute((tool_name == Tools::Read::NAME ? call[:content] : call[:path]).to_s.strip, cwd)
+      return nil unless path
+
+      line = positive(call[:start_line])
+      end_line = line && positive(call[:end_line])
+      new(path: path, line: line, end_line: end_line && end_line > line ? end_line : nil)
+    end
+
+    def self.absolute(raw, cwd)
+      return nil if raw.empty?
+      return File.expand_path(raw) if raw.start_with?("/", "~")
+      return nil if cwd.to_s.empty?
+
+      File.expand_path(raw, cwd)
+    rescue ArgumentError
+      # ~user for a user that doesn't exist.
+      nil
+    end
+    private_class_method :absolute
+
+    def self.positive(value)
+      number = Integer(value.to_s.strip, exception: false)
+      number&.positive? ? number : nil
+    end
+    private_class_method :positive
+  end
+end

data/lib/samagotchi/host_config.rb

@@ -4,6 +4,7 @@ require "uri"
 require_relative "config"
 require_relative "host_model"
 require_relative "llm_context_strategy"
+require_relative "reasoning_history"
 
 module Samagotchi
   # One config.yml hosts: entry, parsed and checked (ConfigFile.hosts_config
@@ -17,8 +18,9 @@ module Samagotchi
   # api: symbols, nil when unset; the rest as HostRegistry::HostEntry
   # describes them, nil when unset; models: {downcased id => HostModel}.
   HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models) do
+                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :models) do
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
@@ -50,6 +52,7 @@ module Samagotchi
         window_tokens: ConfigFile.window_tokens(value.call(:window_tokens), where),
         sampling: ConfigFile.sampling_map(value.call(:sampling), where),
         thinking: Thinking.level(value.call(:thinking), where),
+        reasoning_history: ReasoningHistory.level(value.call(:reasoning_history), where),
         llm_context_strategy: LLMContextStrategy.parse(value.call(LLMContextStrategy::KEY), where),
         llm_context_apply: LLMContextStrategy.parse_apply(value.call(LLMContextStrategy::APPLY_KEY), where),
         models: HostModel.parse_map(value.call(:models), name),
@@ -166,7 +169,7 @@ module Samagotchi
       location.merge("transport" => transport&.to_s, "api" => api&.to_s, "api_key_env" => api_key_env,
                      "profile" => profile, "first_token_timeout" => first_token_timeout,
                      "vision" => vision, "sampling" => sampling, "thinking" => thinking&.to_s,
-                     "remote" => remote, "window_tokens" => window_tokens,
+                     "reasoning_history" => reasoning_history&.to_s, "remote" => remote, "window_tokens" => window_tokens,
                      "llm_context_strategy" => llm_context_strategy&.map(&:to_s),
                      "llm_context_apply" => llm_context_apply&.to_s,
                      "llm_context_budget_tokens" => llm_context_budget_tokens,

data/lib/samagotchi/host_registry.rb

@@ -35,6 +35,7 @@ module Samagotchi
     # vision: the configured true/false (VisionSupport), nil when unset;
     # sampling: the configured request parameters (SamplingSettings), nil when unset;
     # thinking: the configured level (Thinking), nil when unset;
+    # reasoning_history: the configured level (ReasoningHistory), nil when unset;
     # remote: the configured true/false (#remote?), nil when unset;
     # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
     # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
@@ -42,9 +43,9 @@ module Samagotchi
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models,
-                           keyword_init: true) do
+                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :models, keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai