samagotchi 0.22.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9019626f95da411558ec5350303433de58fd07f9db6f9e22323856e4e2ed31a0
-  data.tar.gz: 015df1a469fb64ff5556ce6f683ee23abf039865a34584fff07e3f3c32e4724e
+  metadata.gz: 6d6348260d3f666ffbfc0b8c3f10a51a2c64c3a30ce9cbd5a5c1280fa0325306
+  data.tar.gz: 0cad64155e27a000a49c82e89778d69804fc609526418c1e03846a32d2fb864c
 SHA512:
-  metadata.gz: 1bd652f5d5c2d549dce4eba12cc6577f34cb80ae2a95ea4d63492b4581ed510a5f4eeb8b741f86da7af39198dbfc4981e5d6e7d019dfff7d90f8c0a19722cd6b
-  data.tar.gz: fe6e4cbc412b112d157ad16a1f176fa1308ed094498eb982770b5a6b87859a89c9d544b9c0791d953e0823e51e09396f13e484eccdb240cdd0a0daad8dfe3f8e
+  metadata.gz: b9a1f022f8a225c517e3160d0d512fbb5a97750c32a6df7769bbcb91ddff5534c5b12f540c4ef80871d8e4f2f80d460c71cd56107476435a69d54cef0ef78395
+  data.tar.gz: 419a527ffca2330de67b42544f619db872c06388ded821d3bc5e7f17f07a488a7adf96ce56d55032a53c4bc21e6076d32af398c0b8aff15c48e651e6596e7873

data/CHANGELOG.md

@@ -8,6 +8,75 @@ and commands may change between minor versions. How releases are made:
 
 ## [Unreleased]
 
+## [0.24.0] - 2026-10-04
+
+### Added
+
+- `steer.cut_after` (default 20 s, `0` = never): a message for a running turn from you, `chi send` or a parent
+  agent cuts a generation that has streamed only thinking for that long (counted from its first thinking token;
+  a message that came earlier cuts once the thinking gets there).
+  The model starts the step again with the message, and a `↪ cut in for your message` row marks it. Plugins'
+  steers never cut. Only the cut thinking is lost (llama.cpp re-reads the few tokens after its cached prompt).
+
+### Changed
+
+- The web shows an `execute` / `task_create` call's full command: an expanded tool row has it as a block above the
+  output (whitespace kept, a copy button, `in <cwd>` when the call gave one), and the row's and the stage's hovers
+  show the whole command instead of the 80-character `command="…"` line. The terminal is unchanged.
+- A message that joins a running turn (a line typed in the terminal or the web, `chi send -m`, a delegate's
+  follow-up, `chi answer --option Continue --text`, a plugin's `ctx.steer`) reaches the model with a one-line
+  header naming its sender and asking it to follow the message, or carry on if it asks for nothing, so the model
+  can tell who is steering it. Sessions keep the raw text.
+- The `generation_stopped` log line names who cut the generation as `by=` (was `bundle=`), as a message can cut
+  it now too.
+
+### Fixed
+
+- Guardrails read heredocs (`cat <<'EOF' … EOF`): a heredoc's body no longer asks needlessly (an `rm -rf` or
+  `git push` written into a file by `cat`/`tee`), and an apostrophe in a body no longer hides the commands after it
+  from the strict-mode check for git outside the repo. A body fed to `bash`, `sh` and the like still counts.
+- A `chi send -m` or delegate follow-up merged into a running turn is saved with its sender (`source: chi_send` /
+  `parent_agent`) instead of reading as the user's own words.
+- The idle recap keeps the text of a `chi answer --option Continue --text` (or a continue card answered with
+  text); it was dropped as a plugin's prod.
+- check-in no longer says a nudge was not sent when a user line was merged after it (bundle check-in 0.2.3).
+- A plugin's cut of a generation (loop-guard) with a message or a plugin's steer waiting now delivers it even after
+  `retry.empty_answer`'s budget is spent; the turn used to end cancelled and drop a waiting plugin steer.
+
+Update with `chi update`: check-in moves to 0.2.3 (the nudge-not-sent fix). Restart `chi web` and running sessions
+afterwards (`chi sessions restart ID`).
+
+## [0.23.0] - 2026-10-04
+
+### Changed
+
+- chi no longer strips the blank lines Splash before 1.2.0 put at the start of an answer (incoai/splash#254, fixed
+  in Splash 1.2.0): upgrade Splash with `brew upgrade incoai/tap/splash`.
+- Requests to OpenRouter send `max_tokens: 32768` (a request's own limit, as a recap's, still wins). OpenRouter
+  holds each running request's estimated cost against the balance, counting the output `max_tokens` allows (a
+  fixed per-request cap without one), so concurrent requests hit "would exceed your available credits given your
+  current in-flight requests" (402) sooner without a limit. `default.max_tokens` raises or lowers that limit.
+- `default.n_predict` is renamed `default.max_tokens` (env `SAMAGOTCHI_DEFAULT_MAX_TOKENS`, flag
+  `--default-max-tokens`), with no alias: an old `n_predict:` in config.yml warns as an unknown key. It now
+  limits chat turns on OpenAI-compatible hosts too, sent as `max_tokens` on any host; it was used only by native
+  hosts (where it is still sent as llama.cpp's `n_predict`).
+
+### Fixed
+
+- A Ctrl-C (or SIGTERM) while chi loads bundle hooks and plugins stops chi again; before, it was logged as a
+  failed hook and chi carried on. A hook's or plugin's own error, `exit` or syntax error is still only reported.
+- A continue turn that fails before it begins (its session save, say) asks the step-limit question again
+  instead of crashing the session's worker.
+- Native Gemma 4 prompts follow Gemma 4's chat template: turns end with `<turn|>` (not Gemma 3's
+  `<end_of_turn>`, which Gemma 4 reads as plain text), so the stop sequence matches; tool results stay
+  inside the model's turn as `response:NAME{value:…}` blocks, one per call; tools are declared in the
+  template's compact form at the end of the system turn; an answer's thought is dropped once the next
+  user turn starts; and thinking off prefills Gemma's empty thought channel.
+
+Update with `chi update`: btw 0.1.2, check-in 0.2.2, known-names 0.1.5, loop-guard 0.3.2, mcp 0.4.2, skills 0.1.6 and
+source-links 0.3.3 move (code style only, no behaviour change). If your config.yml has `default: n_predict:`, rename it
+to `max_tokens:`. Restart `chi web` and running sessions afterwards (`chi sessions restart ID`).
+
 ## [0.22.0] - 2026-10-04
 
 ### Added
@@ -1273,7 +1342,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.22.0...HEAD
+[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.24.0...HEAD
+[0.24.0]: https://github.com/dm1try/samagotchi/compare/v0.23.0...v0.24.0
+[0.23.0]: https://github.com/dm1try/samagotchi/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/dm1try/samagotchi/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/dm1try/samagotchi/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/dm1try/samagotchi/compare/v0.19.0...v0.20.0

data/bin/chi

@@ -72,6 +72,7 @@ cli_overrides = {}
 # Strict kebab enforcement: --recap_base_url is unknown (OptionParser would otherwise accept _ as -)
 ARGV.each do |arg|
   next unless arg.start_with?("--") && arg.include?("_")
+
   # Allow --no-interrupt etc. already dash; underscore is always rejected for config flags
   # We check raw ARGV before OptionParser normalizes
   base = arg.split("=", 2).first
@@ -108,7 +109,7 @@ parser = OptionParser.new do |opts|
   opts.on("--[no-]shared", "Run the session in a background worker and attach to it, so `chi web` can share it (the default, config session.shared; with --resume: that session); --no-shared runs a plain in-process REPL") { |v| options[:shared] = v }
   opts.on("--model NAME", "Model for this run, not saved (overrides --resume's; config default.model) [env SAMAGOTCHI_DEFAULT_MODEL]") { |m| options[:model] = m; cli_overrides["default.model"] = m }
   opts.on("--profile NAME", Samagotchi::ModelProfile::NAMES,
-          "Prompt profile for every model in this run (#{Samagotchi::ModelProfile::NAMES.join('|')}) [alias for --model-profile]") { |p| cli_overrides["model.profile"] = p }
+          "Prompt profile for every model in this run (#{Samagotchi::ModelProfile::NAMES.join("|")}) [alias for --model-profile]") { |p| cli_overrides["model.profile"] = p }
   opts.on("--thinking LEVEL", Samagotchi::Thinking::LEVELS.map(&:to_s), "How much the model thinks this run: off|low|medium|high|default (outranks config.yml; " \
                               "sessions already running keep theirs) [env SAMAGOTCHI_THINKING_LEVEL]") { |l| cli_overrides["thinking.level"] = l }
   opts.on("--memory NAME", "Preload a memory entry into the system prompt (repeatable; a comma list too)") { |m| (options[:memories] ||= []) << m }
@@ -133,13 +134,14 @@ parser = OptionParser.new do |opts|
     next if entry.key == "web.port" # already handled as --port
     next if entry.key == "default.model" # alias --model above
     next if entry.key == "web.markdown" # handled below with explicit inverse flags
+
     case entry.type
     when :bool
       # --[no-]: a bool that defaults to on is only useful switched off.
-      opts.on("--[no-]#{entry.cli_flag.delete_prefix('--')}", "Set #{entry.key} (bool, default #{entry.default ? 'on' : 'off'}) [env #{entry.env_key}]") { |v| cli_overrides[entry.key] = v }
+      opts.on("--[no-]#{entry.cli_flag.delete_prefix("--")}", "Set #{entry.key} (bool, default #{entry.default ? "on" : "off"}) [env #{entry.env_key}]") { |v| cli_overrides[entry.key] = v }
     when :integer, :float, :string, :enum
       desc = "Set #{entry.key} [env #{entry.env_key}]"
-      desc += " (#{entry.enum_values.join('|')})" if entry.type == :enum
+      desc += " (#{entry.enum_values.join("|")})" if entry.type == :enum
       desc += " (#{value_hints[entry.key]})" if value_hints.key?(entry.key)
       desc += "; only without a hosts: config" if %w[server.host server.port].include?(entry.key)
       desc += "; hosts: entries without a transport use it" if entry.key == "server.transport"
@@ -257,7 +259,10 @@ if options[:memories] || options[:muted]
   end
   memory_exists = lambda do |raw|
     scope, name = raw.split("/", 2)
-    scope, name = nil, raw unless name && Samagotchi::Tools::VALID_SCOPES.include?(scope)
+    unless name && Samagotchi::Tools::VALID_SCOPES.include?(scope)
+      scope = nil
+      name = raw
+    end
     !Samagotchi::Tools::MemoryRead.call(name, scope: scope).start_with?("Error:")
   end
   cli_memories = (options[:memories] || []).flat_map { |m| m.split(",") }.map(&:strip).reject(&:empty?)

data/docs/cli.md

@@ -274,7 +274,12 @@ Plain `chi` runs the session in a background worker and attaches the terminal
 to it (`session.shared`, default `true`). A worker's session can have any number
 of UIs at once: the Web UI and attached terminals (`chi`, `--resume`,
 `--attach`). They all see the same turns as they happen, and any of them can send
-a prompt, also while a turn runs (it merges into that turn as steering). The
+a prompt, also while a turn runs (it merges into that turn as steering: the model
+is told it is a steer and who sent it). Steering waits for the model's next step,
+unless the model has streamed only thinking for `steer.cut_after` seconds (default
+20), now or while your message waits: then that generation is cut and the step starts again with your message, marked
+`↪ cut in for your message` (see
+[configuration.md](configuration.md#llama-network-retry-behavior)). The
 first answer to an `ask_user_question` wins; the other UIs close their widget.
 An empty answer dismisses the question in every UI. The model is then told
 not to go ahead with what it asked about, or change anything else, and to wait.

data/docs/configuration.md

@@ -308,8 +308,8 @@ prompt profile (see "Prompt profile" below). How the selector reaches the reques
   (`model: Field required`) without it, so samagotchi forwards the selector
   resolved to the exact id listed in the server's `/v1/models` — matched by exact
   (case-insensitive) first, then substring, then passed through unchanged. That
-  resolved id is usually prefixed (e.g. `mlx-community--gemma-3-4b-it-4bit`), so a
-  short selector such as `gemma-3-4b-it-4bit` is what you set in
+  resolved id is usually prefixed (e.g. `mlx-community--gemma-4-e4b-it-4bit`), so a
+  short selector such as `gemma-4-e4b-it-4bit` is what you set in
   `default.model`. An unknown selector passes through raw and oMLX 404s,
   listing its available models; if `/v1/models` is unreachable, samagotchi falls
   back to the raw selector and lets the server decide (its own 400/404). Either
@@ -535,7 +535,7 @@ With several `hosts:`, `host:model` (or an alias naming a host) pins the host.
 An unqualified model name goes to the default host when its `/models` list has
 that exact id, else to the first host in `hosts:` order whose list has it, else
 to the default host. Only exact ids count, never a substring: `/model gemma` on
-a box that lists `gemma-3-12b` needs `box:gemma` or the exact id. The lists are
+a box that lists `gemma-4-26b` needs `box:gemma` or the exact id. The lists are
 known only after `/models` ran (nothing is fetched before the first turn), so
 until then an unqualified name goes to the default host; use `host:model` to pin
 one. A **remote** host (an `https` url or a public address; see "Remote or local") keeps its model
@@ -646,6 +646,14 @@ no made-up answer is saved.
 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).
+A message for a running turn waits for the next step, unless the model's generation has streamed only thinking for
+`steer.cut_after` seconds (default `20`, env `SAMAGOTCHI_STEER_CUT_AFTER`, `0` = never; counted from its first
+thinking token, so the wait for a busy server doesn't count) and still does: then a message from you (the terminal,
+the web), `chi send` or a parent agent cuts that generation, and the model starts the step again with the message
+(`↪ cut in for your message`). A message that comes earlier cuts once the thinking passes `steer.cut_after`, unless
+the step ends first and the message goes in there. Such a cut spends no `retry.empty_answer` attempt and sends no
+hidden note; only the cut thinking is lost. A generation that has streamed visible text or a tool call is never cut,
+and a plugin's steer (`ctx.steer`, `ctx.sessions.send`) never cuts.
 
 Assist-mode UX:
 
@@ -837,7 +845,7 @@ described in their own sections.
 |---|---|---|---|
 | `default.model` | (required) | `--model` | The model a new session starts with; `host:model` pins a host. |
 | `default.input` | none | | Text pre-filled at the first prompt (a trailing space is kept); `--no-default-input` skips it. See [CLI](cli.md). |
-| `default.n_predict` | server's | yes | Most tokens one generation may produce (native hosts). |
+| `default.max_tokens` | server's | yes | Most tokens one generation may produce (`n_predict` on a native llama.cpp host; OpenRouter: 32768 when unset). |
 | `model.profile` | none | `--profile` | Prompt profile for every model (`qwen36`, `gemma4`); env and CLI only. See "Prompt profile". |
 | `server.transport` | `llama_cpp` | yes | `llama_cpp`, `mlx` or `omlx`; see "Model Server Transport". |
 | `server.host` | `localhost` | yes | The model server when there is no `hosts:` map. |
@@ -887,6 +895,7 @@ described in their own sections.
 | `retry.base_delay` | `0.5` | yes | |
 | `retry.max_delay` | `8.0` | yes | |
 | `retry.empty_answer` | `1` | | Times a turn asks again after an empty answer (at most 3, `0` = off). See "Llama Network Retry Behavior". |
+| `steer.cut_after` | `20` | | Seconds a generation must have streamed only thinking before a message for the running turn (yours, `chi send`'s, a parent agent's) cuts it; `0` = never. See "Llama Network Retry Behavior". |
 | `turn.max_iterations` | `100` | | A turn's step limit: model ↔ tool rounds before it stops and asks to continue (an integer ≥ 1). `--no-interrupt` turns get the larger of 1000 and this. See [CLI: Iteration Limit Behavior](cli.md#iteration-limit-behavior). |
 | `turn.parent_continue` | `true` | | Whether a parent agent (`chi answer`) may answer Continue to a session's step-limit question; `false`: Stop only. config.yml only: no environment variable. See [Sub-agent](sub-agent.md) and [Guardrails](guardrails.md#approvals-from-a-parent-agent). |
 | `update.gem` | `true` | | `false`: `chi update` never installs a newer gem (`--no-gem` for one run). See [CLI: Updating](cli.md#updating). |

data/docs/hooks.md

@@ -115,10 +115,16 @@ known-names)` for a bundle hook, `audit.rb (config)` for a config hook,
 `turn hook` for one registered at runtime.
 
 A steer is saved in the session as `{role: "user", kind: "steer", source:
-"<bundle>", content: "…"}`; the model reads only its text, as a user turn.
+"<bundle>", content: "…"}`, its text raw. The model reads it as a user turn
+led by one line naming the sender: `[Steer from the <bundle> plugin,
+mid-task. Follow it; if it asks for nothing, carry on with the task.]`.
 Its `source` is the hook's bundle (a config or turn hook's label otherwise).
-The user's own lines typed into a running turn are saved as `{role: "user",
-kind: "input", content: "…"}`: part of that turn, not a turn of their own.
+Lines typed into a running turn are saved as `{role: "user", kind: "input",
+content: "…"}`: part of that turn, not a turn of their own. They carry a
+`source` when they are not the user's own: `chi_send` (`chi send -m`),
+`parent_agent` (a delegate's follow-up) or `plugin_send` (`ctx.sessions.send`).
+The model reads them with the same kind of header (`[Steer from the user, …]`,
+`[Steer sent with chi send, …]`, and so on).
 
 Timing: a notice from `:after_turn` or `:session_end` shows after the turn's
 end line. A question from `:before_tool_call` shows **before** the tool
@@ -172,19 +178,27 @@ What a cut is, in detail:
 
 - It is an empty answer made early: it uses the `retry.empty_answer` budget
   ([configuration.md](configuration.md#llama-network-retry-behavior)). With
-  no retry left (`retry.empty_answer: 0`, or already used), the turn ends
-  cancelled (hook): "✕ turn canceled (hook)".
+  no retry left (`retry.empty_answer: 0`, or already used) and nothing
+  queued, the turn ends cancelled (hook): "✕ turn canceled (hook)".
 - It shows nothing by itself: post your own notice (`event[:notify]`) to say
   why. The bundle and the reason go into the note the model reads and the
   log (`generation_stopped`).
 - Queued input (the user's line, or a hook's `steer`) goes in place of the
-  hidden note, as for an empty answer; then there is no `↻` line.
+  hidden note, also once the retry budget is spent, and spends no retry;
+  then there is no `↻` line.
 - The cut generation is not kept: its thinking and any visible text it had
   streamed go with it (the retry answers anew). `:after_generation` doesn't
   fire for it, and its token usage is lost (the stream never sent its last
   chunk). A client that joins the running turn still sees its thinking in
   the turn so far until the turn ends.
 - A Stop from the user right after a cut is a plain cancel.
+- A cut for a message (a user's, `chi send`'s or a parent agent's line into
+  a generation that has streamed only thinking for `steer.cut_after` seconds)
+  is not a plugin's cut: it sends no hidden note and spends no retry; the
+  message goes in and the UIs print `↪ cut in for your message`. The
+  stream's `generation_completed` says `stopped_by: "steer"`, and
+  `stop_generation` returns false for a generation a message already cut.
+  A plugin's `steer` never cuts.
 
 ## Presenting the answer (display only)
 

data/docs/plugins.md

@@ -490,7 +490,7 @@ full label, `plugin.rb (bundle my-bundle)`.
 | `ctx.card(title:, body: "", actions: [], level: :info, id: nil)` | a card in every UI, returning its id: see [Cards](#cards) |
 | `ctx.ask_user(question:, options:, header: nil, allow_freeform: false)` | a single-select question through the question flow: `{selected:, freeform:, selected_indices:}`, or nil (no one to ask, cancelled, bad options) |
 | `ctx.cancelled?` | whether the running turn was cancelled (a long tool should stop) |
-| `ctx.steer(text)` | put text into the running turn: its own user message at the loop's next boundary, shown as `my-bundle> nudged: …`. Returns true when queued, false with no turn running (it never starts one; that is `ctx.sessions`' send). Dropped (logged) if the model answers or the turn ends first. Safe from any thread: an anytime command, a hook (false from `:after_turn`), your own |
+| `ctx.steer(text)` | put text into the running turn: its own user message at the loop's next boundary, shown as `my-bundle> nudged: …`. The model reads it with a header naming your bundle (`[Steer from the my-bundle plugin, mid-task. …]`); the session keeps the raw text. Returns true when queued, false with no turn running (it never starts one; that is `ctx.sessions`' send). Dropped (logged) if the model answers or the turn ends first. Safe from any thread: an anytime command, a hook (false from `:after_turn`), your own |
 | `ctx.stop_turn(reason)` | stop the running turn after a warn notice with the reason; true when it stopped one now. In a `:before_tool_call` block it also denies that call |
 | `ctx.stop_generation(reason)` | cut the generation that is streaming: the turn goes on and the model is asked again ([hooks.md](hooks.md#watching-the-stream)). Shows nothing: post your own notice. True when it cut one now |
 | `ctx.ask_model(messages:, prompt:, …)` | a side answer from the session's model: see [Side answers](#side-answers-ctxask_model) |

data/docs/releasing.md

@@ -52,7 +52,7 @@ as the GitHub release body.
 | `rake bundles:check` | Sha lines match; a bundle changed since the last `v*` tag has a higher version (skipped, with a note, before the first tag). Warns (doesn't fail) when such a bundle's `requires_chi` still admits the tagged chi: raise it if the change uses anything new. |
 | `rake release:draft_changelog` | A draft Unreleased section from the commit subjects since the last tag, grouped. Stdout only. |
 | `rake release:bump[X.Y.Z]` | VERSION, the system manifest, Gemfile.lock, CHANGELOG. No commit. |
-| `rake release:check` | Clean tracked tree, VERSION == system bundle, a CHANGELOG section, `bundles:check`, rspec + npm test, `gem build`, then a clean install into a temp GEM_HOME that runs `chi --version`, `chi self` and `chi bundle list` with a temp HOME. Needs the network (gem dependencies). |
+| `rake release:check` | Clean tracked tree, VERSION == system bundle, a CHANGELOG section, `bundles:check`, `rake lint` (RuboCop), rspec + npm test, `gem build`, then a clean install into a temp GEM_HOME that runs `chi --version`, `chi self` and `chi bundle list` with a temp HOME. Needs the network (gem dependencies). |
 | `rake release:notes[X.Y.Z]` | Prints the CHANGELOG section (default: the current VERSION). |
 
 ## Runbook

data/docs/sub-agent.md

@@ -60,9 +60,10 @@ answers waits as a question of kind `continue` (`"limit": 100`, options
 `Continue` and `Stop`). `answer_with` continues it:
 `chi answer ID --question QID --option Continue`, and the continued turn's
 reply (or its next question) comes back on that same wait. With
-`--text "…"` the text joins the continued turn as a steer (as a `chi send -m`
-into a running turn does, marked as coming from the parent agent), so one
-answer continues and redirects it. To stop it:
+`--text "…"` the text joins the continued turn as a steer, labelled for the
+model as coming from the parent agent that started the session, so one answer
+continues and redirects it. (A `chi send -m` into a running turn joins it too,
+labelled as sent with chi send.) To stop it:
 `--option Stop`, with `--text "why"` for the model;
 that wait ends with `status: not_continued`, exit 0, and the turn's work so far
 stays in the session. A message instead (`chi send ID -m "…"`) drops the

data/docs/testing.md

@@ -4,8 +4,14 @@
 bundle exec parallel_rspec -n 8   # Ruby specs, in parallel (or plain: bundle exec rspec)
 npm test                          # web frontend specs
 npm run e2e                       # web UI happy paths in Chromium, fake model (once: npx playwright install chromium)
+bundle exec rake lint             # RuboCop: no offenses (CI runs it)
 ```
 
+Run `bundle exec rubocop -a` on the files you changed before committing: every enabled style cop follows the
+code's own style and has a safe autocorrect, so `-a` fixes them. What it leaves is a Lint finding (a possible
+bug) or a broken spec: fix it, or disable that line with the reason (`# rubocop:disable Cop -- why`).
+`.rubocop.yml` says why each cop that is off is off.
+
 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).
 

data/lib/samagotchi/answer_command.rb

@@ -84,12 +84,14 @@ module Samagotchi
       options = parsed.options
       return usage_error("give one session id") unless parsed.args.size == 1
       return usage_error("--question QID is required (chi send --wait prints it)") if options[:question].to_s.strip.empty?
+
       if options[:dismiss]
         return usage_error("--dismiss takes no --option or --text") if !options[:options].empty? || options[:text]
       elsif options[:options].empty? && options[:text].nil?
         return usage_error("nothing to answer with: --option, --text or --dismiss")
       end
       return usage_error("--format takes text or json") if options[:format] && !FORMATS.include?(options[:format])
+
       if options[:timeout]
         options[:timeout] = Float(options[:timeout], exception: false)
         return usage_error("--timeout takes seconds") unless options[:timeout]&.positive?
@@ -155,7 +157,7 @@ module Samagotchi
     # (Guardrails::ParentApprovals, with this process's config.yml). A
     # Deny, text alone or a dismissal always passes: each one denies. The
     # worker checks it again with its own config.
-    def approval_refusal(pending, selected, id)
+    def approval_refusal(pending, selected, _id)
       offered = Array(pending[:options]).map(&:to_s)
       indices = selected.map { |label| offered.index(label) }
       reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: Guardrails::ParentApprovals.setting)
@@ -170,7 +172,7 @@ module Samagotchi
 
     # A step-limit question can't be left unanswered: the turn waits on it.
     def not_dismissable(pending)
-      "the step-limit question can't be dismissed: answer #{Array(pending[:options]).join(' or ')} " \
+      "the step-limit question can't be dismissed: answer #{Array(pending[:options]).join(" or ")} " \
         "(--option Stop --text WHY stops it)"
     end
 

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -15,7 +15,8 @@ module Samagotchi
     # comments), after a backup, and is checked by parsing it again: every
     # other key must be unchanged, or the backup goes back.
     class ConfigWriter
-      Error = Class.new(StandardError)
+      class Error < StandardError
+      end
 
       # kind: :new (a fresh file), :appended, :exists (the host is already
       #   there as +existing+; nothing written), :snippet (a file chi can't

data/lib/samagotchi/bootstrap/probe.rb

@@ -18,7 +18,7 @@ module Samagotchi
     # port answers at once instead of after chi's usual backoff.
     class Probe
       # The ports `chi bootstrap` with no target tries on localhost.
-      LOCAL_PORTS = { 8080 => "llama.cpp", 11434 => "Ollama", 1234 => "LM Studio", 8000 => "vLLM" }.freeze
+      LOCAL_PORTS = { 8080 => "llama.cpp", 11_434 => "Ollama", 1234 => "LM Studio", 8000 => "vLLM" }.freeze
       DEFAULT_PORT = 8080
       # Connect and read seconds for /props and /v1/models: a remote https
       # handshake needs more than Client#server_props' 1 s / 2 s.

data/lib/samagotchi/bootstrap_command.rb

@@ -193,7 +193,7 @@ module Samagotchi
     def describe(result)
       if result.native?
         build = result.props["build_info"].to_s
-        @stdout.puts("found: llama.cpp at #{result.candidate.root}#{build.empty? ? "" : " (build #{build})"}")
+        @stdout.puts("found: llama.cpp at #{result.candidate.root}#{" (build #{build})" unless build.empty?}")
       else
         @stdout.puts("found: an OpenAI-compatible API at #{result.candidate.base}")
       end
@@ -406,7 +406,7 @@ module Samagotchi
         shown.first(PICK_SHOWN).each_with_index { |item, i| @stdout.puts(format("  %2d) %s", i + 1, item)) }
         more = shown.size - PICK_SHOWN
         @stdout.puts("  … #{more} more: type part of a name to narrow the list") if more.positive?
-        @stdout.print("#{noun} (number#{items.size > PICK_SHOWN ? " or text" : ""}, empty to stop): ")
+        @stdout.print("#{noun} (number#{" or text" if items.size > PICK_SHOWN}, empty to stop): ")
         answer = @stdin.gets.to_s.strip
         return nil if answer.empty?
 

data/lib/samagotchi/bridge/bounded_queue.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
-
 module Samagotchi
   class Bridge
     # A thread-safe bounded FIFO used to decouple the turn thread (which

data/lib/samagotchi/bridge/card_store.rb

@@ -16,7 +16,7 @@ module Samagotchi
     # iteration started before it (a before_tool_call hook's notice comes
     # before its call's row, so the web puts it above row calls + 1). The
     # loop's "asking again" row (:empty_answer_retry, after an empty or cut
-    # answer) is kept the same way, and so is a question the turn asked
+    # answer) and a steer's cut row (:steer_cut) are kept the same way, and so is a question the turn asked
     # (:question_requested), with how it was answered or cancelled, so a
     # reload draws the resolved card where it was.
     #
@@ -46,11 +46,11 @@ module Samagotchi
     # onto a new worker doesn't print those again).
     class CardStore
       CAPACITY = 20
-      NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry].freeze
+      NOTICE_TYPES = %i[hook_notice guardrail_warning empty_answer_retry steer_cut].freeze
       FILE = "cards.json"
       # The events after which the file is written again: the ones that
       # change an entry or the turn count.
-      SAVED_ON = (%i[card hook_notice empty_answer_retry question_requested question_answered question_cancelled
+      SAVED_ON = (%i[card hook_notice empty_answer_retry steer_cut question_requested question_answered question_cancelled
                      question_relay turn_failed] + Events::TURN_KEPT).freeze
 
       # What a session's saved file lists, as a store started from it lists
@@ -167,6 +167,7 @@ module Samagotchi
         when :guardrail_warning then push({ type: :guardrail_warning, message: event[:message], label: event[:label] }
                                             .compact.merge(in_turn: false, turns: @turns_done))
         when :empty_answer_retry then add_turn_row(event.slice(:type, :attempt, :of, :stopped_by)) if @running
+        when :steer_cut then add_turn_row(event.slice(:type, :source)) if @running
         when :question_requested
           add_turn_row({ type: :question, pending_question: Marshal.load(Marshal.dump(event[:pending_question])) }) if @running
         when :question_answered then resolve_question(event[:id], answer: event[:answer])

data/lib/samagotchi/bridge/sse_writer.rb

@@ -217,8 +217,6 @@ module Samagotchi
           "\r\n"
         )
         io.flush
-      rescue Errno::EPIPE, Errno::ECONNRESET, IOError
-        raise
       end
 
       # Serialise one SSE event: an `id:` line (the replay cursor), an optional
@@ -232,15 +230,11 @@ module Samagotchi
         JSON.generate(data).each_line { |line| lines << "data: #{line.chomp}" }
         io.write(lines.join("\r\n") + "\r\n\r\n")
         io.flush
-      rescue Errno::EPIPE, Errno::ECONNRESET, IOError
-        raise
       end
 
       def write_heartbeat(io)
         io.write(": ping\r\n\r\n")
         io.flush
-      rescue Errno::EPIPE, Errno::ECONNRESET, IOError
-        raise
       end
 
       # Emit a control frame carrying the current snapshot so a client that

data/lib/samagotchi/bridge/turn_accumulator.rb

@@ -158,7 +158,8 @@ module Samagotchi
         call = { iteration: part[:iteration], call_index: part[:call_index], tool: part[:tool] }
         call[:label] = part[:label] if part[:label]
         title = part[:title] ? { title: part[:title] } : {}
-        events = [{ type: :tool_call_started, **call, params: part[:params], **title }]
+        view = part[:view] ? { view: part[:view] } : {}
+        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?
           return events
@@ -170,6 +171,7 @@ module Samagotchi
                       activity: activity }
         completed[:duration_ms] = part[:duration_ms] unless part[:duration_ms].nil?
         completed[:diff] = part[:diff] if part[:diff]
+        completed.merge!(view)
         events << with_images(completed, part[:images])
       end
       private_class_method :tool_replay_events
@@ -230,8 +232,8 @@ module Samagotchi
         if Events::TURN_END.include?(type)
           @turn = nil
           @merged_origins = []
-        else
-          @turn[:event_seq] = event[:event_seq] if event[:event_seq]
+        elsif event[:event_seq]
+          @turn[:event_seq] = event[:event_seq]
         end
       end
 
@@ -253,6 +255,7 @@ module Samagotchi
                    tool: event[:tool], params: event[:params], status: "running" }
           part[:label] = event[:label] if event[:label]
           part[:title] = event[:title] if event[:title]
+          part[:view] = event[:view] if event[:view]
           parts << part
           @tool_started_at[[event[:iteration], event[:call_index]]] = @clock.call
         when :tool_call_completed

data/lib/samagotchi/bridge/turn_notice.rb

@@ -12,6 +12,7 @@ module Samagotchi
       FIELDS = {
         hook_notice: %i[hook text level],
         empty_answer_retry: %i[iteration attempt of stopped_by],
+        steer_cut: %i[iteration source],
         question_requested: %i[pending_question],
         question_answered: %i[id answer],
         question_cancelled: %i[id reason]

data/lib/samagotchi/bridge.rb

@@ -20,6 +20,7 @@ require_relative "session"
 require_relative "engine"
 require_relative "guardrails/parent_approvals"
 require_relative "session_commands"
+require_relative "steer"
 require_relative "image_store"
 require_relative "log"
 require_relative "version"
@@ -481,7 +482,7 @@ module Samagotchi
       %w[GET snapshot] => :handle_snapshot,
       %w[GET tail] => :handle_tail
     }.freeze
-    ROUTE_PATH = %r|\A/session/([^/]+)/(.+)\z|u
+    ROUTE_PATH = %r{\A/session/([^/]+)/(.+)\z}u
 
     # @return [Array(Symbol, String), nil] the handler and the session id, or
     #   nil when no route takes this method and path
@@ -509,7 +510,7 @@ module Samagotchi
     # /recap in an attached TUI: the saved recap, and a new one asked for at
     # once (it arrives as :recap_ready). Answers mid-turn too.
     # 200 {enabled:, saved:, request:, min_user_turns:}. Returns [headers, status, body].
-    def handle_recap(session_id, _body = nil)
+    def handle_recap(_session_id, _body = nil)
       recap = @engine.recap
       return [{}, 200, { enabled: false }] unless recap
 
@@ -519,7 +520,7 @@ module Samagotchi
 
     # Cancel the active turn on this session's engine, if any.
     # Returns [headers, status, body].
-    def handle_cancel(session_id, body)
+    def handle_cancel(_session_id, body)
       # Optional reason from JSON body
       reason = :manual
       if body && !body.strip.empty?
@@ -546,6 +547,7 @@ module Samagotchi
       unless parsed.is_a?(Hash)
         return [{ "Allow" => "POST" }, 400, { error: "invalid_json" }]
       end
+
       qid = fetched(parsed, "id")
       selected = fetched(parsed, "selected")
       freeform = fetched(parsed, "freeform")
@@ -556,6 +558,7 @@ module Samagotchi
       if qid.to_s.strip.empty?
         return [{ "Allow" => "POST" }, 400, { error: "missing_fields", detail: "id required" }]
       end
+
       deadline = fetched(parsed, "deadline")
       return BAD_DEADLINE unless deadline_valid?(deadline)
       return deadline_passed("answer") if expired?("answer_expired", deadline, sid: session_id, id: qid)
@@ -722,6 +725,7 @@ module Samagotchi
         @on_exit_request.call(client_id, **options)
       end
       return deadline_passed("exit request") if reason == :expired
+
       if reason.nil?
         return [{}, 200, { status: "restarting", session_id: @session_id }] if restart
 
@@ -745,7 +749,7 @@ module Samagotchi
     # dropped with 408 deadline_passed. It is checked with the event log held,
     # right before the write, so nothing that holds the log (an exit check)
     # can delay an accepted turn past it. No deadline (an older client): taken.
-    def handle_post_turn(session_id, body)
+    def handle_post_turn(_session_id, body)
       parsed = parse_json(body)
       unless parsed.is_a?(Hash)
         return [{ "Allow" => "POST" }, 400, { error: "invalid_json" }]
@@ -777,6 +781,8 @@ module Samagotchi
       end
 
       enqueued_id = SecureRandom.uuid
+      # Before it is queued: a drain after this may have taken it (#cut_for_steer).
+      epoch = @engine.input_epoch
       # Write and announce with the event log held: the worker can't emit
       # this turn's :turn_started (or merge it mid-turn) before
       # :turn_enqueued, and a failed write announces nothing.
@@ -796,12 +802,16 @@ module Samagotchi
       return deadline_passed("turn") if enqueued == :expired
       return [{}, 500, { error: "enqueue_failed", detail: "could not write turn input" }] unless enqueued
 
+      # Queued (outside the event lock): a running generation that has only
+      # been thinking for long is cut for it, unless a plugin sent it. An
+      # image input never merges mid-turn, so it never cuts.
+      @engine.cut_for_steer(Steer.source_for_client(client_id), epoch: epoch) if images.empty?
       [{}, 202, { status: "accepted", enqueued_id: enqueued_id, session_id: @session_id }]
     end
 
     # Read-only snapshot surface. AC #4: too-old reconnects re-derive state
     # from here.
-    def handle_state(session_id, _body = nil)
+    def handle_state(_session_id, _body = nil)
       state = @engine.session_state_snapshot
       [{}, 200, { session_id: @session_id, session_state_snapshot: state.merge(event_id: event_id(state[:event_seq])) }]
     end
@@ -809,7 +819,7 @@ module Samagotchi
     # /stats for an attached client: the metrics, with the window and prompt
     # profile asked from the server when no turn has reported them yet (so,
     # unlike /state, it may wait on one short /props GET).
-    def handle_stats(session_id, _body = nil)
+    def handle_stats(_session_id, _body = nil)
       [{}, 200, { session_id: @session_id, metrics: @engine.stats_snapshot }]
     end
 
@@ -817,7 +827,7 @@ module Samagotchi
     # the messages elsewhere (the web server strips and formats them): it then
     # streams from the snapshot's event_seq, and the ring replays what came
     # after (or the stream resets). Returns [headers, status, body].
-    def handle_snapshot(session_id, _body = nil)
+    def handle_snapshot(_session_id, _body = nil)
       [{}, 200, snapshot_frame]
     end
 
@@ -825,7 +835,7 @@ module Samagotchi
     # that turn's answer (a queued turn's page re-reads late). The one
     # handler that gets the query (#dispatch); an older worker's route
     # ignores it and sends the newest answer.
-    def handle_tail(session_id, _body = nil, query = nil)
+    def handle_tail(_session_id, _body = nil, query = nil)
       turn_id = query && URI.decode_www_form(query).to_h["turn_id"].to_s
       [{}, 200, tail_frame(turn_id: turn_id.to_s.empty? ? nil : turn_id)]
     rescue ArgumentError
@@ -885,7 +895,7 @@ module Samagotchi
       headers = {}
       content_length = 0
       while (line = io.gets)
-        break if line == "\r\n" || line == "\n"
+        break if ["\r\n", "\n"].include?(line)
 
         key, value = line.split(":", 2)
         next unless key