samagotchi 0.64.0 → 0.66.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61245b8998baef2bbb4c29cabc648314b4cc124cf9233099948cb7cf66dc890e
-  data.tar.gz: ac4e8fa165b5cc59d683b1541a3758e03f60a1d14b7fd9cded087770fda162de
+  metadata.gz: 0f78cadf95c501357ce71b15b672dee0a4558016b995a1948532924168580f86
+  data.tar.gz: 583f9594eed0ed2febe41390e9c2e0dfbfbde2df72c92f6eab5d8d6a3cf8d776
 SHA512:
-  metadata.gz: 717ca2421c97d4f93493891e4f695528a0b8495ab11a2b47c348b29c726004abb32e638ab21b3e6af62676acfc4cc31c45527bdb9dfe72a9a270b3f7bfda3e02
-  data.tar.gz: 4916e876cf70f3b1b03e8c7554a127019e08e3b6f2e991305c8fe63ce1f6cf399155c43167ff36382c09eb2774792a4783ccbe39109702df6bd4efbe67a1ff53
+  metadata.gz: 312f72d24bbfc6543d0899f164e69798d068916cef8728242d54893a783c3da7efceb2cbbfeac0337790596984af221e78f5c98541a910945266a2a1122e6ef7
+  data.tar.gz: 347d52314752545c6fbc37e7b1a7186faadb6fa2170f91e00b35b8101c76ed9b0ee80b8b954ea927382583c97511dae2fd0a6eca28b694778657f1b654c81226

data/CHANGELOG.md

@@ -8,6 +8,91 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.66.0] - 2026-10-14
+
+### Added
+
+- **Plugin annotation actions** (web): `chi.annotation(label, command:, template:, send:)` adds a pill to the
+  selection bar that prepares a command line of the plugin from the selected text (`{quote}`, `{text}`, `{source}`):
+  it fills the composer (an earlier draft stays under the quote), or with `send: true` sends at once. Up to 3 inline,
+  the rest behind `⋯`. See docs/plugins.md, `chi.annotation`.
+- claude-peer 0.2.0: **Confirm with Claude** in the web's selection bar fills `/claude validate` with the quote;
+  `/claude validate|context` titles a quote by its first quoted line, not its `From …:` label.
+- The codex-peer bundle (in the dev profile): claude-peer for an OpenAI Codex CLI session. Codex pairs (its
+  `chi-peer` skill, installed by `/codex install-skill`), the `codex_send` tool and `/codex validate|context|last`
+  send it a part of the work with `codex queue` (killed after 10 s, never a hang), and Codex's answer comes back as
+  the `codex-review` context; **Confirm with Codex** in the web's selection bar. Codex's sandbox needs chi's
+  context folder in `writable_roots` (the install card shows the line). See docs/plugins.md, "The codex-peer bundle".
+- **Toolkits**: a session's toolkit names the tools its prompts declare. chi ships `full` (every built-in, the
+  default), `lean` (the file, shell, memory, task, question, `web_fetch` and `context_read` tools: ~1.4k tokens
+  fewer) and `child` (`lean` with `send_note`, without `memory_write`); config's `toolkit.kits` and bundles
+  (`chi.toolkit`) add their own. Pick one with `toolkit.default` / `toolkit.child`, `chi --toolkit NAME` (with
+  `--tool` / `--no-tool`, also on `chi send --new`) or `/toolkit NAME | add TOOL | remove TOOL`. It is saved in the
+  session when it is created and kept by continues and forks; a change applies at the next turn's start. A left-out
+  tool is named in one prompt line, and a call to it is refused before the guardrails. The web shows a session not
+  on `full` as a `tools` chip. See docs/configuration.md, "Toolkits".
+- Plugins: `ctx.toolkit` and `ctx.use_toolkit(name)` (before the session's first reply). The coordinator bundle
+  (0.4.0) declares the `coordinator` toolkit (`lean` + `delegate`, `delegate_result`, `list_sessions`), and
+  `/coordinate` puts a fresh session on it.
+
+### Changed
+
+- A command's name may be followed by any whitespace, a newline too: `/foo` on its own line with text under it
+  runs `/foo` with that text, in the terminals and the web (before, only a space did).
+- Web: a command refused as busy mid-turn comes back into the composer (it was cleared when sent).
+- A delegate child is told to report what should change (a wrong memory or skill, instructions that led it astray)
+  in its reply instead of writing memories (`delegated.md`).
+
+### Fixed
+
+- `dialect: fireworks` hosts: the web's ctx meter no longer reads 0% while an answer streams (Fireworks' first stream
+  event carries all-zero usage; its counts come at the end).
+
+**Still open:** the Claude 5.x "bound to a different conversation" 400 on Anthropic Messages hosts (see 0.65.0); its
+recovery comes in a later release.
+
+Update with `chi update` (the system bundle moves with the gem; claude-peer 0.2.0, coordinator 0.4.0, and the dev
+profile 0.5.0 with the new codex-peer 0.1.0).
+
+## [0.65.0] - 2026-10-13
+
+### Added
+
+- **Anthropic Messages hosts** (`api: anthropic`): streamed text and thinking, native tool use, images, usage with
+  cache reads and writes, thinking blocks replayed verbatim (also after `--resume`; `reasoning_history` defaults to
+  `all` there). A new host key `auth: bearer|x-api-key` (any host) picks the header the key goes in. Thinking levels
+  map to Messages' thinking (`off` disabled, `low`/`medium`/`high` adaptive at that effort, `default` nothing), with
+  fallbacks when a host refuses a field. Recaps, `ctx.ask_model` and broadcast triage work there too. See
+  docs/configuration.md, "Anthropic Messages hosts". **Known limit until the next release:** Claude 5.x models
+  (Opus, Sonnet and Haiku 5.5, Fable 5.1) may stop a turn with a 400 "… bound to a different conversation" after the
+  history changed under their thinking blocks; the next release adds the recovery.
+- `dialect: fireworks` on an `api: anthropic` host, for Fireworks directly or behind a gateway: Bearer auth, no
+  thinking `display`, no `cache_control`, and `x-session-affinity` for cache routing. `chi self` names it.
+- A provider's refusal (Messages `stop_reason: refusal`, or an empty `content_filter` stop) ends the turn with
+  `no answer: refused by the provider (category)` in every UI and isn't retried. A `content_filter` stop after some
+  text keeps the text, marked `[cut off by the provider's content filter]`.
+- Web composer: a row above the text field shows the keys while idle and, while a turn runs, where a message sent now
+  goes in (after this thinking step, tool call or answer, with its clock), with `cut in now` and `queue for after the
+  turn` links. Alt+Enter (Option+Enter) queues. See docs/cli.md, "Typing during a turn".
+- Terminal: while a turn runs, the status row ends in `· typing goes in at the next step (/cut, /queue)`.
+
+### Changed
+
+- Web: a message queued for after the running turn sits below the running turn's card, not among its rows, also
+  after a reload.
+- A chat host that refuses a sampling field (`temperature`, `top_p`, `top_k`) gets the step again without it instead
+  of the turn failing; on `api: openai` hosts such a 400 no longer turns reasoning off.
+- A Splash or Fireworks model's vision comes from its model list instead of reading "unknown".
+
+### Fixed
+
+- A server error without a numeric code is classified by its type: an invalid request fails at once instead of being
+  retried, an unknown model (404, `NOT_FOUND`) is no longer retried, a `timeout_error` is a 504.
+- Anthropic's context-overflow 400s ("prompt is too long", "input length and `max_tokens` exceed context limit")
+  roll the turn back and report it as too long for the context window, also through a gateway on the OpenAI path.
+
+Update with `chi update` (the system bundle moves with the gem).
+
 ## [0.64.0] - 2026-10-13
 
 ### Added
@@ -2794,7 +2879,9 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.64.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.66.0...HEAD
+[0.66.0]: https://github.com/dm1try/samagotchi/compare/v0.65.0...v0.66.0
+[0.65.0]: https://github.com/dm1try/samagotchi/compare/v0.64.0...v0.65.0
 [0.64.0]: https://github.com/dm1try/samagotchi/compare/v0.63.0...v0.64.0
 [0.63.0]: https://github.com/dm1try/samagotchi/compare/v0.62.0...v0.63.0
 [0.62.0]: https://github.com/dm1try/samagotchi/compare/v0.61.0...v0.62.0

data/README.md

@@ -153,7 +153,8 @@ in a child session in its own git worktree, check each report and ask you
 before each merge; `/children` shows the children and their state. With the
 `claude-peer` bundle (in `dev`), chi sends a part of its work to a Claude Code
 session you pair it with, to validate or as context, and Claude answers back
-into chi (`/claude`).
+into chi (`/claude`); the `codex-peer` bundle (in `dev`) does the same with an
+OpenAI Codex CLI session (`/codex`).
 
 `chi send` is the other half: the text goes in as your message, the same as
 typing it in the attached terminal or the web composer, and a turn runs. Piped

data/bin/chi

@@ -82,7 +82,7 @@ ARGV.each do |arg|
   base = arg.split("=", 2).first
   # If dashed version is a known flag (registry or hardcoded), reject underscore variant
   dashed = base.tr("_", "-")
-  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
+  known = %w[--prompt --resume --attach --shared --no-shared --model --thinking --toolkit --tool --no-tool --memory --mute --append-system-prompt --llm-context --llm-context-apply --llm-context-budget --no-interrupt --non-interactive --verbose --no-default-input --port --open --new-token] + Samagotchi::Config.cli_entries.map(&:cli_flag)
   if known.include?(dashed) || known.include?(base)
     warn "Unknown option: #{arg} (did you mean #{dashed}?)"
     exit 1
@@ -119,6 +119,12 @@ parser = OptionParser.new do |opts|
   opts.on("--thinking LEVEL", Samagotchi::Thinking::LEVELS.map(&:to_s), "This session's own thinking level: off|low|medium|high|default (saved in the session, " \
                               "before the model's; default unsets it; /thinking changes it). With chi web: the default for the sessions " \
                               "its workers run, below a session's own [env SAMAGOTCHI_THINKING_LEVEL]") { |l| options[:thinking] = l }
+  opts.on("--toolkit NAME", "This session's toolkit, the tools its prompts declare: full|lean|child|a config or bundle one " \
+                           "(saved in the session; config toolkit.default; /toolkit changes it)") { |n| options[:toolkit] = n }
+  opts.on("--tool NAME", "Also declare this tool on top of the toolkit (repeatable; a comma list too)") { |t| (options[:tools] ||= []) << t }
+  # --no-tool is taken out of ARGV before parse! (OptionParser would read it
+  # as --tool's negation); this is its help line.
+  opts.separator "        --no-tool NAME               Leave this tool out of the toolkit (repeatable; a comma list too)"
   opts.on("--memory NAME", "Preload a memory entry into the system prompt (repeatable; a comma list too)") { |m| (options[:memories] ||= []) << m }
   opts.on("--append-system-prompt FILE", "Put FILE's text into the system prompt, after AGENTS.md (repeatable; saved in the session; " \
                                         "config append_system_prompt: is the baseline)") { |f| (options[:append_system_prompt] ||= []) << f }
@@ -171,6 +177,34 @@ parser = OptionParser.new do |opts|
   opts.on("--version", "Print chi's version") { puts "chi #{Samagotchi::VERSION}"; exit }
   opts.on("-h", "--help", "Show help") { puts opts; exit }
 end
+# --no-tool NAME (or --no-tool=NAME), up to a "--". A flag that takes a
+# value (-p, --model …: the parser's own list) keeps its next word, so
+# `chi -p "--no-tool=x is broken"` is a prompt. A tool name never starts
+# with "-": `--no-tool --` or `--no-tool --model` is a missing argument.
+takes_value = parser.instance_variable_get(:@stack).flat_map do |list|
+  list.list.select { |switch| switch.is_a?(OptionParser::Switch::RequiredArgument) }.flat_map { |switch| switch.long + switch.short }
+end
+missing_no_tool = lambda do
+  warn "Error: missing argument: --no-tool (see chi --help)"
+  exit 1
+end
+index = 0
+while index < ARGV.size && ARGV[index] != "--"
+  arg = ARGV[index]
+  if arg == "--no-tool"
+    value = ARGV[index + 1]
+    missing_no_tool.call if value.nil? || value.start_with?("-")
+    (options[:no_tools] ||= []) << ARGV.delete_at(index + 1)
+    ARGV.delete_at(index)
+  elsif arg.start_with?("--no-tool=")
+    value = arg.delete_prefix("--no-tool=")
+    missing_no_tool.call if value.empty? || value.start_with?("-")
+    options[:no_tools] = (options[:no_tools] || []) << value
+    ARGV.delete_at(index)
+  else
+    index += takes_value.include?(arg) ? 2 : 1
+  end
+end
 begin
   parser.parse!
 rescue OptionParser::ParseError => e
@@ -327,6 +361,17 @@ if options[:append_system_prompt]
   end.uniq
 end
 
+# --toolkit/--tool/--no-tool: a new session's toolkit, as named (the
+# worker resolves it; a bundle's toolkit isn't known here).
+if options[:toolkit] || options[:tools] || options[:no_tools]
+  require "samagotchi/toolkit"
+  # The flags as given, for the line an existing session's run prints.
+  options[:toolkit_flags] = [("--toolkit" if options[:toolkit]), ("--tool" if options[:tools]),
+                             ("--no-tool" if options[:no_tools])].compact
+  options[:toolkit_value] = Samagotchi::Toolkit.from_flags(name: options[:toolkit], add: options[:tools],
+                                                           remove: options[:no_tools])
+end
+
 chi_update_hint.call
 require "samagotchi/launch_mode"
 launch, launch_note = if scratch
@@ -361,7 +406,9 @@ if launch == :attached
                                                        muted_memories: options[:muted] || [],
                                                        llm_context: options[:llm_context] || {},
                                                        thinking: options[:thinking],
-                                                       appended_prompt_files: options[:appended_prompt_files] || [])
+                                                       appended_prompt_files: options[:appended_prompt_files] || [],
+                                                       toolkit: options[:toolkit_value],
+                                                       toolkit_flags: options[:toolkit_flags] || [])
   rescue Samagotchi::TerminalUI::AttachLauncher::Error => e
     warn "Error: #{e.message}"
     exit 1
@@ -381,6 +428,8 @@ begin
     llm_context: options[:llm_context] || {},
     thinking: options[:thinking],
     appended_prompt_files: options[:appended_prompt_files] || [],
+    toolkit: options[:toolkit_value],
+    toolkit_flags: options[:toolkit_flags] || [],
     non_interactive: options[:non_interactive],
     model_name: options[:model],
     scratch: scratch

data/docs/architecture.md

@@ -100,7 +100,7 @@ terminal renders the events it gets over the Bridge.
 | Core | `Samagotchi::Engine` | System prompt, memory injection, tool declarations, session lifecycle, model↔tool loop (`run_turn`). No terminal coupling. |
 | UI | `Samagotchi::TerminalUI` | REPL (Reline), rendering, REPL commands. Delegates all core work to an `Engine`. |
 | Model loops | `KernelLoop` (via `LLM::NativeBackend`), `LLM::ChatLoop` | The model↔tool loop: raw prompt or OpenAI chat API, chosen per host (see below). |
-| Adapters | `Samagotchi::Client`, `LLM::OpenAIChat`, `LLM::HTTP` | Raw-prompt servers, the OpenAI chat API, and the HTTP both share. |
+| Adapters | `Samagotchi::Client`, `LLM::OpenAIChat`, `LLM::AnthropicMessages`, `LLM::HTTP` | Raw-prompt servers, the OpenAI chat API, Anthropic's Messages API, and the HTTP they share. |
 | Tools | `lib/samagotchi/tools/*` | Execute, read, edit, write, memory, task_*, web_fetch, delegate/delegate_result, ask_user_question, reminders, send_note, list_sessions, context_read, forget_outputs, plus runtime/output-guardrails. |
 | Bundles | `lib/samagotchi/memory_bundle/*`, `BundleCommand` | `chi bundle`: install/upgrade (3-way merge), build, uninstall; the install record under `.bundles/<name>/` that the hook, guardrail and plugin loaders read ([internals/bundles.md](internals/bundles.md)). |
 | Background | `Samagotchi::Worker`, `Samagotchi::SessionManager` | `SessionManager` forks/spawns one worker process per session; its `Worker` builds the `Engine` and `Bridge` (no terminal rendering) and runs queued turns. The spawned process (own process group) forks the worker, which `setsid`s and is reparented to init once its starter exits (it waits until the worker holds `owner.lock`, so the spawner's `Process.detach` waiter tells a starting worker): nothing that walks the spawner's process tree reaches it (`SAMAGOTCHI_WORKER_DETACH=1`, `detach_from_spawner`). The lock's pid is the worker's; `spawn`'s `child_pid` is its starter's. |
@@ -398,6 +398,7 @@ Engine picks the loop from the effective model's host (`HostRegistry#resolve`):
 |---|---|---|---|
 | Raw prompt | `KernelLoop`, wrapped by `LLM::NativeBackend` | no `api:`, or `llama_cpp`/`mlx`/`omlx` | `Client` (`/completion` or `/v1/completions`), chi's own Gemma/Qwen prompt and tool-call parsing |
 | Chat | `LLM::ChatLoop` | `api: openai` | `LLM::OpenAIChat` (`/v1/chat/completions`, streamed, native tool calls) |
+| Chat | `LLM::ChatLoop` | `api: anthropic` | `LLM::AnthropicMessages` (`/v1/messages`, streamed SSE, native `tool_use`) |
 
 Both return an `LLM::ModelResult` and emit the same stream events; tool calls in
 both go through `ToolRunner` (events, hooks, veto, output cap) and
@@ -438,12 +439,28 @@ threshold puts the model's own `[CONTEXT: …]` line on the tail as a system
 message (docs/internals/context-telemetry.md).
 
 **Adapters.** `Client` (raw-prompt servers) and `LLM::OpenAIChat` (one per host,
-`HostRegistry#adapter_for`) share `LLM::HTTP`: timeouts, TLS for https, a line
-reader for streamed bodies, the retry loop (`retry.*`; network errors, 429 and
+`HostRegistry#adapter_for`, built by `LLM::Adapters` from the host's api) share
+`LLM::HTTP`: timeouts, TLS for https, a line reader for streamed bodies, the retry loop (`retry.*`; network errors, 429 and
 500/502/503/504/529, honouring `Retry-After`; never after a stream has produced
 output) and cancel. Cancel closes the in-flight socket from the
 `CancellationController` listener, so it works on any thread.
 
+`LLM::AnthropicMessages` talks Anthropic's Messages API (`POST {root}/v1/messages`) for the same chat loop:
+ChatLoop builds the same OpenAI-shaped wire messages for every chat host, and the adapter translates them
+(`LLM::AnthropicWire`: the head system message becomes the top-level `system` blocks, tool calls `tool_use` blocks,
+tool messages `tool_result` blocks in one user message, image parts `image` blocks, later system messages user
+text; empty text blocks are never sent). Its answer (`LLM::AnthropicAssembly`) is a `ChatResponse` whose
+`provider_content` holds the content blocks as received, which ChatLoop saves on the model entry as
+`anthropic_content` (string keys, so a resumed session sends the same bytes) and sends back verbatim when the
+adapter `replays_content?` (only for entries whose calls are all paired, never for an interrupted one; earlier
+entries' thinking blocks left out under `reasoning_history: turn`) (thinking blocks
+need their signature and their order among text and `tool_use`). Usage is normalized to the OpenAI shape the rest
+of chi reads (the prompt is input + cache reads + cache writes), stop reasons to the loop's finish reasons
+(`max_tokens` → `length`, `tool_use` → `tool_calls`, `end_turn` → `stop`). A stream is read by content-block index
+from the `data:` lines alone (`event:` lines are not needed); `message_start` / `message_delta` events reach
+`on_delta` with that normalized `usage`, pings not at all, and a block's start or delta counts as shown for the
+first-token limit. Both adapters share their model-list cache (`LLM::ModelListing`).
+
 **Errors.** A failed request raises an `LLM::ProviderError` of one kind:
 `ConnectionError` (`RetryExhausted`), `RateLimited` (`CreditsHeld`: a 402 about
 credit held by in-flight requests, retried after 20 s), `OutOfCredits` (any other

data/docs/cli.md

@@ -187,6 +187,7 @@ controls exit behavior (`--non-interactive`); `--resume` composes with both.
 | `--attach SESSION_ID` | Attach to a session's worker, waking one if it has exited. |
 | `--model NAME` | Use this model for the run (overrides the configured default and a resumed session's model). |
 | `--thinking LEVEL` | This session's own thinking level: `off`, `low`, `medium` or `high`, saved in the session and first in the order (`default` unsets it). On `--resume` or `--attach` it is set at once, through a `/thinking` on an attached worker. With `chi web` it is instead the default for the sessions its workers run, below a session's own (as env `SAMAGOTCHI_THINKING_LEVEL` is). See "Thinking" in configuration.md. |
+| `--toolkit NAME`, `--tool NAME`, `--no-tool NAME` | A new session's toolkit, the tools its prompts declare: `full` (every built-in), `lean`, `child`, one of config's `toolkit.kits` or a bundle's (without `--toolkit`: config's `toolkit.default`), with tools declared on top of it (`--tool`) or left out (`--no-tool`); both repeatable, a comma list too. Saved in the session as given; a respawned worker, a fork and a continue keep it. Ignored with `--attach`/`--resume` (one line, as `--memory`); `/toolkit` changes it. Not on `chi web` (config's `toolkit.default` covers its sessions). See [Toolkits](configuration.md#toolkits). |
 | `--profile NAME` | Prompt profile (`qwen36` or `gemma4`) for every model in this run, over config and the server's template (same as `--model-profile`, env `SAMAGOTCHI_MODEL_PROFILE`). See "Prompt profile" in configuration.md. |
 | `--memory NAME` | Preload a memory entry into the system prompt (repeatable; a comma list too). Merged under the config.yml `memories:` baseline. Works attached: the list is stored on the session, so its worker builds the same prompt on every respawn. |
 | `--append-system-prompt FILE` | Put `FILE`'s text into the system prompt, after AGENTS.md and before the memory indexes (repeatable; relative to the shell's directory). Added after the config.yml `append_system_prompt:` list. A missing or unreadable file is an error, exit 1. Saved in the session, so a respawned worker, a fork and a continue keep it; ignored with `--attach`/`--resume` (one line, as `--memory`). See [Appended prompt files](configuration.md#appended-prompt-files). |
@@ -513,7 +514,16 @@ reasoning of the turn it continues. `/stats` shows it on its `reasoning history:
 line, the web as the `reasoning` chip. See "Reasoning history" in
 [configuration.md](configuration.md).
 
-A `/thinking` or `/reasoning-history` change that restarts the prompt cache
+`/toolkit` lists the tools the next turn declares (each with its estimated
+tokens), the session's toolkit and the tools it leaves out. `/toolkit NAME` puts
+the session on another toolkit (dropping its own adds and removes); `/toolkit
+add TOOL` and `/toolkit remove TOOL` change one tool (a tool's name keeps its
+case). The change is saved at once and applies from the next turn's start; a
+running turn keeps its tools. `/toolkit` alone answers mid-turn too; a change
+sent while a turn runs waits for the turn's end. The web shows a session that
+isn't on `full` as the `tools` chip. See [Toolkits](configuration.md#toolkits).
+
+A `/thinking`, `/reasoning-history` or `/toolkit` change that restarts the prompt cache
 asks first: the reply says what it costs, changes nothing, and names the line
 that applies it (`/thinking low --yes`). `--yes` (or `-y`) applies it at once.
 The terminal puts that line in the next input (Enter applies it); the web's
@@ -555,6 +565,26 @@ REPL alike:
   sent after it still go in at the next step.
   At the open prompt (no turn running) `/cut TEXT` and `/queue TEXT` run TEXT
   as a normal prompt.
+- **The web composer** has a row above the text field in a session (always
+  there, so the composer never changes height): the keys while idle, and while
+  the turn runs the delivery line, where a message sent now goes in (`↳ goes in after this
+  thinking step · 0:42 · 3k chars`, `… after this tool call (execute · 0:12)`,
+  `… after this answer; the turn may go on`, `… once the card above is
+  answered`), then two links. **Enter** (or Send) is the next step;
+  **Alt+Enter** (Option+Enter) or `queue for after the turn` queues it, like
+  `/queue TEXT`, and the bubble is dashed (`after this turn`), below the
+  running turn's card with the commands queued for its end, until its turn
+  starts; `cut in now` cuts, like `/cut TEXT` (by click only: it throws the
+  thinking away). Cut is enabled only while the step has streamed nothing but
+  thinking and cutting is on for the model (the line says `cuts at about 0:25
+  if you choose cut in now` until the thinking passes `steer_cut_after`, and
+  `cutting is off for <model>` with no cut link when it is 0); the queue link
+  is gone for a worker too old to queue (Alt+Enter then sends nothing, keeps the
+  text and says to restart the worker). A link clicked with an empty composer
+  arms that choice (`cut in now ✓ · Enter sends`); a second click or Esc lets
+  go of it. The echo says what it waits for: `waits for the next step` or
+  `cutting in…`, then `steered`. A phone shows the short form (`↳ after this
+  thinking · 0:42`) with `cut in` and `queue` chips.
 - Commands answer, wait or are refused, by what they do:
   - At once, beside the turn: `/stats`, `/recap`, `/help`, `/context`, a
     plugin's anytime command (`/btw`), and the commands that only show
@@ -708,7 +738,9 @@ approval, a hook's question and the step limit don't): two muted lines
 under its `question → answer` line, the whole text when you open the card,
 in both views and after a reload. The chip at the stage's bottom edge, `N steps · M tool
 calls` with one tick per call, opens the turn view's block right above it (newest step first
-while it runs; a tick opens its step). `▾` folds the stage to its status
+while it runs; a tick opens its step). Below the chip, past a dashed rule, wait the
+messages queued for after the turn and the commands queued for its end; they go into
+the history after the turn's answer. `▾` folds the stage to its status
 row, remembered in this browser. The stage keeps its height while a turn
 runs: it grows, with a short ease, when a card or the answer needs room and gives the room back
 only when the turn moves into the history. When the turn ends the answer shows in
@@ -953,6 +985,8 @@ status> model=Qwen3.6-35B | ⑂ 2 running · 1 waiting | ctx=8.1% (under20) | me
   report none, `api: openai`, at the turn's end).
 - `mem:`: the memories the session read, with its `--memory` list; `muted:` its `--mute` list.
   Up to 8 names each, then `+N`.
+- While a turn runs it ends in `· typing goes in at the next step (/cut, /queue)`; the hint is the first thing dropped
+  on a narrow terminal.
 - The row is cut to the terminal's width. Without a live region (output or input not a terminal,
   `TERM=dumb`) it prints as a line when it changes.
 - `SAMAGOTCHI_STATUS_LINE` / `status.line` (default `on`): `off`, `false` or `0` hides it.

data/docs/configuration.md

@@ -231,7 +231,8 @@ hosts:
 
 `chi self` shows the variable and whether it is set (`api key  FIREWORKS_API_KEY (set)`).
 
-Every host with `api_key_env:` sends `Authorization: Bearer <key>` on each request,
+Every host with `api_key_env:` sends `Authorization: Bearer <key>` on each request (`api: anthropic`:
+`x-api-key: <key>`, see [Anthropic Messages hosts](#anthropic-messages-hosts)),
 chat or raw-prompt alike, so a llama.cpp started with `--api-key` works as a native
 host too (`chi bootstrap --key-env VAR` writes such an entry). An unset variable
 fails the turn before any request (`set VAR`); a 401/403 names the variable to
@@ -292,6 +293,90 @@ workers, and resumed sessions all use the loop of the model's host. Hosts withou
 `api: openai` keep using the native `/completion`, `/v1/completions`, or oMLX
 transport path.
 
+### Anthropic Messages hosts
+
+`api: anthropic` makes a host talk Anthropic's Messages API (`POST {url}/v1/messages`) through the same chat loop:
+Anthropic's own API, a gateway that serves `/v1/messages`, or a local server that does (Splash). The url is the API
+root **without** `/v1`, as `ANTHROPIC_BASE_URL` takes it (a url that ends in `/v1` is accepted: no second `/v1` is
+added); an entry with neither `url:` nor `host:` talks to `https://api.anthropic.com`. The key goes in the
+`x-api-key` header; `auth: bearer` sends it as `Authorization: Bearer` instead (a gateway or provider that wants
+that), `auth: x-api-key` is the default spelled out. Exactly one of the two headers is sent.
+
+```yaml
+hosts:
+  claude:
+    api: anthropic
+    api_key_env: ANTHROPIC_API_KEY
+  gateway:
+    url: https://gateway.example.com
+    api: anthropic
+    api_key_env: GATEWAY_KEY
+    auth: bearer
+  splash-msg:
+    url: http://192.0.2.10:8000
+    api: anthropic
+```
+
+`auth:` works on any host (`bearer` is the default everywhere but `api: anthropic`).
+
+**Known limit (until a later release):** Claude 5.x models (Opus, Sonnet and Haiku 5.5, Fable 5.1) bind each
+thinking block to the request it came from. When the history before a block changes (the system prompt rebuilt after a
+worker restart or a `/model` switch, a changed tool set, the forget layer's edits), such a model may answer HTTP 400
+"… bound to a different conversation" and the turn fails with that error; `/reasoning-history turn` makes it rarer.
+A later release sends Anthropic's binding controls and recovers from that 400. Fireworks, Splash and other
+non-Claude models are not affected.
+
+The loop, tools, events, hooks and UIs are the chat loop's, as for `api: openai`; only the wire differs: the
+system prompt goes as the request's `system` (later system notes as user text), tool calls as `tool_use` blocks,
+results as `tool_result` blocks, images as `image` blocks; thinking streams into the thinking lane; usage counts
+cache reads and writes into the prompt (so `/stats` shows them). Without `default.max_tokens`, `max_tokens` is the
+model list's `max_tokens` capped at 64000, else 64000 (Messages requires one). chi's OpenAI-only request fields are
+never sent there; `sampling:` passes as written.
+
+Its model list is `GET {url}/v1/models` (every page): Anthropic's shape (the window from `max_input_tokens`, images
+from `capabilities.image_input`) or the OpenAI shape a gateway, Splash or Fireworks serves there (images from
+`input_modalities`, `vision` or `supports_image_input`). A gateway whose list lacks an
+id (a high-availability alias) takes it from the host's declared `models:`, as on any host.
+
+**Dialects.** A provider whose `/v1/messages` departs from Anthropic's gets `dialect:` on its host (only on
+`api: anthropic`; an unknown value, or a dialect on another api, warns once and is ignored). `chi self` names it on
+its `loop` line. `dialect: standard` is the default written out. There is one other dialect today, `fireworks` (Fireworks' Anthropic-compatible API, directly or behind a gateway):
+
+- the key goes as `Authorization: Bearer` (an explicit `auth:` still wins);
+- thinking at `low`/`medium`/`high` is `{type: "adaptive"}` with `output_config.effort`, without `display` (Fireworks'
+  schema has none and refuses unknown fields; it returns thinking by default); a model switched to the budget form gets
+  none either;
+- no `cache_control` breakpoints (Fireworks caches prompt prefixes by itself);
+- `x-session-affinity: <session id>` beside `Session-Id`, so a session stays on one replica, where its cache is.
+
+A host without `dialect:` is standard Anthropic (Claude, Splash). Give each upstream kind its own host entry: when a
+gateway serves both Fireworks models and Claude ids on one url, the Claude ids go on a second entry with the same url
+and no `dialect:` (Claude wants `display: summarized` and the breakpoints).
+
+```yaml
+hosts:
+  work-msg:                               # the work gateway's Messages route, Fireworks behind it
+    url: https://gateway.example.com      # the API root, no /v1 (chi adds /v1/messages)
+    api: anthropic
+    dialect: fireworks                    # Bearer auth, no thinking display, no cache_control, x-session-affinity
+    api_key_env: WORK_API_KEY
+    # auth: x-api-key                     # only if the gateway itself wants that header
+    thinking: medium                      # low|medium|high → output_config.effort; off → thinking disabled
+    models:
+      accounts/fireworks/models/kimi-k2p5:
+        price: {input: 0.6, cache_read: 0.1, output: 2.5}    # example rates: put the gateway's (no cache writes on Fireworks)
+  work-claude:                            # the same gateway's Claude ids: standard Messages
+    url: https://gateway.example.com
+    api: anthropic
+    api_key_env: WORK_API_KEY
+    auth: bearer                          # if the gateway wants Bearer for Claude ids too
+  fireworks:                              # Fireworks directly
+    url: https://api.fireworks.ai/inference
+    api: anthropic
+    dialect: fireworks
+    api_key_env: FIREWORKS_API_KEY
+```
+
 To manually verify a live chat-loop tool round trip, run the gated integration
 spec. It requires the model to call `execute` and return the current UTC date:
 
@@ -512,7 +597,13 @@ models:
 - `/model` shows the level and where it came from (`thinking: off (models: qwen3.6-35b-a3b)`, `thinking: low
   (session)`), `/stats` on its `thinking:` line, `chi self` too (a session's own level first when run from its
   commands).
-- The idle recap and plugins' side questions always ask with thinking off, whatever the level.
+- The idle recap, plugins' side questions and a broadcast's triage always ask with thinking off, whatever the
+  level. A model that refuses that gets no thinking fields on an `api: openai` host (its default); on an
+  `api: anthropic` host, where such a model always thinks, it gets adaptive thinking at `low` effort and a limit of
+  at least 4096 tokens, so the thinking leaves room for the answer; a model that refuses that too (one that takes no
+  thinking fields at all) gets none, at the normal limit. What a host refused is kept for the next recap, the next
+  `ctx.ask_model` on the same model, and the rest of a broadcast. A recap and `ctx.ask_model` send the session's id
+  as the turns do (`Session-Id`, and `x-session-affinity` under `dialect: fireworks`); a triage sends none.
 
 What each backend gets:
 
@@ -521,6 +612,20 @@ What each backend gets:
 | native (`/completion`), `qwen36` | an empty thought after the assistant cue, and no turn preamble | no knob: thinking stays as the model has it, one notice |
 | native, `gemma4` | no `<\|think\|>` token at the start of the system prompt | no knob, one notice |
 | chat host (`api: openai`) | `chat_template_kwargs: {enable_thinking: false}` and `reasoning_effort: "none"` | `reasoning_effort: <level>` |
+| Messages host (`api: anthropic`) | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive", display: "summarized"}` and `output_config: {effort: <level>}` |
+| Messages host, `dialect: fireworks` | `thinking: {type: "disabled"}` | `thinking: {type: "adaptive"}` and `output_config: {effort: <level>}` (no `display`) |
+
+On a Messages host `default` sends nothing: the provider's own default, which differs by model (some Claude models
+think adaptively but show no thinking text, their blocks still going back; others, and Splash, don't think at all). A model that refuses `disabled` (current
+Claude models) gets the request again without it, as on any chat host. A model that refuses adaptive thinking
+(older Claude: Haiku 4.5) is switched, once and for the worker's life, to the budget form: `thinking: {type:
+"enabled", budget_tokens: B}` with B 2048 / 8192 / 24576 for low / medium / high and no effort; `max_tokens` always
+stays above the budget (the budget is lowered to leave 1024 for the answer, or `max_tokens` raised to 2048). A
+host that refuses the thinking `display` field gets thinking without it from then on (the level still applies); one
+that refuses `cache_control` gets no cache breakpoints from then on, and a `max_tokens` over the model's output
+limit is sent again with the limit the host names. On any chat host, a model that refuses a sampling field
+(`temperature`, `top_p`, `top_k`; Claude refuses the empty-answer retry's temperature while thinking) gets the
+request again without them, and none of them after.
 
 On chat hosts: llama.cpp honours both off switches but ignores the effort (when its `/props` says
 `chat_template_caps.supports_reasoning_effort: false`, chi says so once per session and host, from the `/props`
@@ -593,10 +698,17 @@ models:
   turns included, and answers HTTP 400 without it: under `turn` every turn after one that thought fails. Set
   `reasoning_history: all` there (the example above). DeepSeek through OpenRouter takes `turn`.
 - `drop` sends none (what chi did before this setting).
+- **On an `api: anthropic` host** the reasoning goes back as the answer's own content blocks, verbatim (thinking
+  blocks with their signatures, in their order among text and `tool_use`), not as `reasoning_content`. The default
+  there is `all`: Claude keeps earlier turns' thinking in context, and leaving it out would rewrite the cached prefix
+  each turn (a Qwen template on Splash drops earlier turns' reasoning itself, so `all` costs nothing there). `turn`
+  leaves earlier turns' thinking blocks out (their text and calls stay), and `drop` counts as `turn`: the running
+  turn's thinking blocks always go back (a tool loop with thinking needs the last reply's). An interrupted reply, or
+  one whose tool calls never got their results, goes back as plain text without its blocks.
 - `all` sends every reply's reasoning, earlier turns too. It sends only the field: a local template that leaves out
   earlier turns' reasoning (Qwen's) needs `preserve_thinking` as well (above).
 - Order, first set wins: the session's own level, `SAMAGOTCHI_REASONING_HISTORY` (the whole process; for A/B runs),
-  the `models:` entry (found the way `profile:` is), the `hosts:` entry, then `turn`. Anything else than a level warns
+  the `models:` entry (found the way `profile:` is), the `hosts:` entry, then `turn` (`all` on `api: anthropic`). Anything else than a level warns
   once and counts as unset. A host's level reaches a worker when it starts, as its `sampling:` does.
 - **A session's own level** (`drop`, `turn` or `all`; an explicit `turn` counts as its own) is saved in the session
   (its file's `"reasoning_history"`), so a `--resume`, a respawned worker, a continue and `/model` keep it; a plugin's
@@ -627,10 +739,10 @@ models:
 
 ## Changes that restart the prompt cache
 
-`/thinking` and `/reasoning-history` ask before a change that makes the server read the conversation again: Gemma's
-thinking switch, a remote chat host's thinking fields ("Thinking"), and a change to or from `all` once an earlier reply
-has thinking ("Reasoning history"). They ask only when the level the next turn runs under really changes and the
-session has a model reply.
+`/thinking`, `/reasoning-history` and `/toolkit` ask before a change that makes the server read the conversation again:
+Gemma's thinking switch, a remote chat host's thinking fields ("Thinking"), a change to or from `all` once an earlier
+reply has thinking ("Reasoning history"), and any change to the declared tools, which start every request
+("Toolkits"). They ask only when what the next turn runs under really changes and the session has a model reply.
 
 - The reply says what it costs and changes nothing yet: `Nothing changed yet: send /thinking low --yes to apply.`
 - `--yes` (or `-y`, anywhere after the command) applies it at once.
@@ -891,6 +1003,12 @@ many times per turn; `0` ends the turn at the empty answer as before. An answer
 (90 % or more) is not retried. When the retries run out the turn ends with no answer: every UI shows one muted line,
 `no answer: the model returned nothing (after 1 retry)`, and the model is told on its next turn with a hidden note;
 no made-up answer is saved.
+A provider that refuses the answer (a Messages host's `stop_reason: refusal`, or an OpenAI-compatible host's
+`finish_reason: content_filter` with no text) is not asked again: the turn ends with no answer (text streamed before
+a Messages refusal is not kept), every UI shows `no answer: refused by the provider (cyber)` (the category from
+`stop_details`, when there is one), and the hidden note says the answer was refused. A `content_filter` stop after
+some text keeps that text as the answer, followed by `[cut off by the provider's content filter]`, and is not asked
+again either. Tool calls that come with either are not run.
 A generation a plugin cuts while it streams (loop-guard's thinking watch, or any `stop_generation`,
 [hooks.md](hooks.md#watching-the-stream)) uses the same budget: `↻ cut by loop-guard, asking again (1/1)`, and with
 none left the turn ends as cancelled (hook).
@@ -959,6 +1077,13 @@ message (before, a failed llama.cpp `/completion` ended the turn as
 | bad request | other 4xx; a prompt larger than the context window, whatever the status | no |
 | protocol | a body the API doesn't promise | no |
 
+An error event (or an error body inside a 200) has no HTTP status of its own: its numeric `error.code` stands for
+one, or a Google-style code name (Fireworks: `INVALID_ARGUMENT` 400, `UNAUTHENTICATED` 401, `PERMISSION_DENIED` 403,
+`NOT_FOUND` 404, `RESOURCE_EXHAUSTED` 429), else its `error.type` (Anthropic's names; some OpenAI-compatible servers,
+OpenAI and Ollama, use some of them: `invalid_request_error` 400, `authentication_error` 401, `billing_error` 402,
+`permission_error` 403, `not_found_error` 404, `request_too_large` 413, `rate_limit_error` 429, `api_error` 500,
+`timeout_error` 504, `overloaded_error` 529); with neither it counts as a 500.
+
 The turn's prompt and its completed tool calls stay in the session.
 
 ## Debug Log File
@@ -1151,6 +1276,48 @@ work tree top when inside it, else with `~`.
   picked up by a new process or a rebuild (`/model`). `/stats` lists the files
   in the prompt on its `prompt files:` line.
 
+## Toolkits
+
+A session's **toolkit** names the tools its prompts declare. The declared tools are the front of every request (the
+`tools` field, or the native template's declarations), so a session that declares fewer sends a shorter prompt, and
+sessions on the same toolkit share that prefix in a prompt cache.
+
+```yaml
+toolkit:
+  default: lean        # the sessions you start (unset: full)
+  child: child         # delegate children (unset: full)
+  kits:                # your own, on a base
+    review: { base: lean, add: [web_fetch, delegate], remove: [memory_write] }
+```
+
+| toolkit | declares |
+|---|---|
+| `full` | every built-in; the default |
+| `lean` | `execute`, `read`, `write`, `edit`, `memory_read`, `memory_write`, `task_create`, `task_wait`, `task_get`, `task_list`, `task_stop`, `ask_user_question`, `web_fetch`, `context_read` |
+| `child` | `lean` plus `send_note`, without `memory_write` |
+| `coordinator` | `lean` plus `delegate`, `delegate_result`, `list_sessions` (declared by the coordinator bundle) |
+
+- **Plugin tools** are declared in every toolkit unless its `remove:` names them, and so is `forget_outputs` under
+  the `forget` layer. A `kits:` entry takes `base:` (default `full`), `add:` and `remove:`; it can't reuse a
+  built-in's name. A bundle declares its own with `chi.toolkit` ([plugins](plugins.md#chitoolkitname-base-add--remove-)).
+- **Saved at creation, never re-resolved from config.** A session stores its toolkit as named
+  (`"toolkit": {"name": "lean", "add": [], "remove": []}`) when it is created: `toolkit.default`, `toolkit.child`
+  for a delegate child, or `chi --toolkit NAME` / `--tool` / `--no-tool` ([cli](cli.md)). Changing `toolkit.default`
+  doesn't move existing sessions, not even when their worker is woken again; a session from before toolkits is on
+  `full`. A continue and a fork keep the toolkit. `/toolkit` shows and changes it.
+- **Not loaded.** When a toolkit leaves tools out, one line after the base prompt names them (`Not loaded in this
+  session (toolkit lean): …. Only the user can load one (/toolkit add <name>).`). A call to one is refused before
+  the guardrails (no approval card): `Error: delegate isn't loaded in this session (toolkit lean) …`.
+- **Applied at a turn's start.** A change (`/toolkit`, a plugin's `ctx.use_toolkit`) is saved at once and the next
+  turn declares it; once the session has a model reply, `/toolkit` asks first ("Changes that restart the prompt
+  cache").
+- **A name that doesn't resolve** (a typo, a bundle that was uninstalled) declares every tool for that process,
+  with one `toolkit>` warning at the first turn; the saved name stays, so the bundle's return brings it back.
+- **Versions.** A toolkit's definition can change with chi or a bundle, which changes what saved sessions on it
+  declare after an upgrade: the next request reads the prompt again once, as a tool's schema change does. So can
+  an edit to `toolkit.kits`: a session's worker reads the kits once when it starts, so a running session keeps its
+  tools and the edit reaches it at its next worker start (after an idle exit, `chi sessions restart`).
+
 ## LLM context: the forget layer
 
 Experimental, off by default. With `forget` in a model's `llm_context.strategy` (next to `stale`), chi offers that
@@ -1290,7 +1457,7 @@ Every setting below takes the three forms described in
 marked config.yml only) and, where the CLI
 column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 `model_aliases:`, `hooks:`, `guardrails:` rules, `bundles:`, `memories:`,
-`append_system_prompt:`) are described in their own sections.
+`append_system_prompt:`, `toolkit.kits`) are described in their own sections.
 
 | Setting | Default | CLI | What it does |
 |---|---|---|---|
@@ -1358,6 +1525,8 @@ column says so, a `--kebab-name` flag. The maps (`hosts:`, `models:`,
 | `context.status_thresholds` | `20,40,60,80` | yes | Percentages that put the estimate into a bucket; the rise into a guidance bucket (from the second up) leaves the model its own `[CONTEXT: …]` line, and the bucket decides the guidance. |
 | `context.every_seconds` | `300` | | How often an attached context source's command runs when it has no `--every` (seconds, at least 30). See [Attached context](context.md). |
 | `context.wake` | `true` | yes | A source whose update says `wake: true` may start a turn in a live, idle session (one per source per 10 minutes, within `session.max_wakes`); so may a session's pushed source's first push. `false`: updates wait as notes for the next turn. See [Waking](context.md#waking). |
+| `toolkit.default` | `full` | | The toolkit a new session is stored on: the tools its prompts declare (`full`, `lean`, `child`, one of `toolkit.kits` or a bundle's). `chi --toolkit` picks one per session. See "Toolkits". |
+| `toolkit.child` | `full` | | A delegate child's toolkit. See "Toolkits". |
 | `thinking.turn_preamble` | `true` | yes | Ask a `qwen36` model to open its thinking with a short `TURN:` line (the step label). |
 | `reasoning_history` | `turn` | | Which of its reasoning a chat host's model gets back: `drop`, `turn`, `all`; environment only (`SAMAGOTCHI_REASONING_HISTORY`), below a session's own level (`/reasoning-history`), above the `models:`/`hosts:` entries. See "Reasoning history". |
 | `thinking.level` | `default` | `--thinking` | `off`, `low`, `medium`, `high` or `default` for every model; the flag and env outrank the `models:`/`hosts:` entries, the file's value doesn't; a session's own level outranks them all, and `--thinking` sets it on a session run (on `chi web` it sets this). See "Thinking". |

data/docs/context.md

@@ -126,7 +126,10 @@ pbpaste | chi context push clip --project
 A Claude Code session can be a pushed source too: the
 [claude-peer bundle](plugins.md#the-claude-peer-bundle)'s `pair` script attaches
 `claude-inbox` (Claude's inbox socket as the hint) and `claude-review`, where
-Claude pushes its answers as JSON with `wake: true`.
+Claude pushes its answers as JSON with `wake: true`. The
+[codex-peer bundle](plugins.md#the-codex-peer-bundle)'s does the same for a
+Codex session: `codex-inbox` (Codex's thread id as the hint) and
+`codex-review`.
 
 ### A stream: chat, a log, a feed