samagotchi 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236e301c873eb2b96520aeeb3e7668e535f50174b1afb94d28a149cef161d418
-  data.tar.gz: adc3281cace9460e307abe5abc33719041863898e848f10b290d5d2d3e4c93d5
+  metadata.gz: 6d6348260d3f666ffbfc0b8c3f10a51a2c64c3a30ce9cbd5a5c1280fa0325306
+  data.tar.gz: 0cad64155e27a000a49c82e89778d69804fc609526418c1e03846a32d2fb864c
 SHA512:
-  metadata.gz: 6e97629a0a1459a7c9b403a495aea87807f4b2570421e369a56a01afd140830b8284e7d25a86132f14ebdab95275913f66caa8aea48680d23b507dec9d57b519
-  data.tar.gz: 284540411644a596492ad2d91c36eecb23f8eb435b95e06781e387b4933a6210680e15b6d79f035b1abd029b726aa9489bdee39816a9d509bfb7a1810b92b00e
+  metadata.gz: b9a1f022f8a225c517e3160d0d512fbb5a97750c32a6df7769bbcb91ddff5534c5b12f540c4ef80871d8e4f2f80d460c71cd56107476435a69d54cef0ef78395
+  data.tar.gz: 419a527ffca2330de67b42544f619db872c06388ded821d3bc5e7f17f07a488a7adf96ce56d55032a53c4bc21e6076d32af398c0b8aff15c48e651e6596e7873

data/CHANGELOG.md

@@ -8,6 +8,44 @@ 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
@@ -1304,7 +1342,8 @@ and long-lived sessions.
 - A macOS desktop helper (`chi desktop install`): a "Send to chi" Service and a
   hotkey panel that send selected text or the clipboard to your sessions.
 
-[Unreleased]: https://github.com/dm1try/samagotchi/compare/v0.23.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

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

@@ -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:
 
@@ -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/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/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/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
@@ -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"
@@ -780,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.
@@ -799,6 +802,10 @@ 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
 

data/lib/samagotchi/bundles/check-in/manifest.yml

@@ -1,10 +1,10 @@
 ---
 name: check-in
-version: 0.2.2
+version: 0.2.3
 scope: system
 description: "Checks on a long turn: after N tool calls with no answer, a card asks the user (Nudge / Keep going / Stop), or the model is nudged to say what it has found"
 trust_level: reviewed
 plugin:
   file: plugin.rb
-  sha256: sha256:52fcb0a3beccfee1e70e7d73162eace603da11bee43e535b1bc17d55eae98334
+  sha256: sha256:821aea2821df12f278db9a94f8150244e67bf9453735d19a5abe9d94253eefa6
 requires_chi: ">= 0.3.0"

data/lib/samagotchi/bundles/check-in/plugin.rb

@@ -147,7 +147,8 @@ class Plugin
       role = (message[:role] || message["role"]).to_s
       kind = (message[:kind] || message["kind"]).to_s
       return true if kind == "steer" && (message[:content] || message["content"]).to_s.strip == text.strip
-      return false if role == "user" && kind != "steer"
+      # A user line merged into the turn (kind input) is part of it: look past it.
+      return false if role == "user" && !%w[steer input].include?(kind)
     end
     false
   end

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

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

data/lib/samagotchi/config.rb

@@ -144,6 +144,10 @@ module Samagotchi
       # Asks again in the same turn after an empty answer (EmptyAnswerRetry);
       # 0 = off, capped at 3. No CLI flag: workers get no CLI args.
       Entry.new(key: "retry.empty_answer",       yaml_path: %w[retry empty_answer],       type: :integer, default: 1,               expose: %i[env config]),
+      # Seconds a generation must have streamed only thinking before a message
+      # for the running turn (the user's, chi send's, a parent agent's) cuts
+      # it (Engine#cut_for_steer); 0 = never. No CLI flag: workers get no CLI args.
+      Entry.new(key: "steer.cut_after",          yaml_path: %w[steer cut_after],          type: :integer, default: 20,              expose: %i[env config]),
       # A turn's step limit: model ↔ tool rounds before it stops and offers to continue (IterationLimit); integer ≥ 1.
       # --no-interrupt turns get max(1000, this). No CLI flag: --no-interrupt is the flag.
       Entry.new(key: "turn.max_iterations",      yaml_path: %w[turn max_iterations],      type: :integer, default: 100,             expose: %i[env config]),

data/lib/samagotchi/engine.rb

@@ -47,6 +47,8 @@ require_relative "tools/memory"
 require_relative "muted_memories"
 require_relative "used_memories"
 require_relative "turn_state"
+require_relative "generation_phase"
+require_relative "waiting_steer"
 require_relative "bundle_needs"
 require_relative "model_overlay"
 require_relative "served_model"
@@ -103,6 +105,10 @@ module Samagotchi
       # steers) and the idle layer's activity clock. Built first: a plugin
       # may steer or ask whether a turn runs while it loads.
       @turn_state = TurnState.new(clock: -> { monotonic_now })
+      # What the running generation streams: whether a steer may cut it.
+      @generation_phase = GenerationPhase.new(clock: -> { monotonic_now })
+      # A message that may cut it but came too early: it cuts later.
+      @waiting_steer = WaitingSteer.new
       @scratch = scratch
       @no_interrupt = no_interrupt
       @chat_backend = nil
@@ -325,6 +331,69 @@ module Samagotchi
       @turn_state.steer(text, source: source)
     end
 
+    # A message for the running turn from +source+ (Steer.source_for_client:
+    # nil for the user, "chi_send", "parent_agent") cuts the streaming
+    # generation when it has streamed only thinking for steer.cut_after
+    # seconds (GenerationPhase): the loops' cut path then starts the step
+    # again with the message, no nudge, no retry spent. Too early, the
+    # message waits (WaitingSteer) and cuts once the thinking passes it
+    # (#recheck_waiting_steer, on each thinking chunk), unless a boundary
+    # hands it to the model first. A plugin's message never cuts.
+    # Call it after the message is queued, with the #input_epoch read
+    # before queueing it. Outside any lock; a cut that lands just after the
+    # generation ended is harmless (the loop re-asks).
+    # @return [Boolean] whether a generation was cut now
+    def cut_for_steer(source, epoch: nil)
+      return false unless Steer.cuts?(source)
+
+      after = Config.get("steer.cut_after").to_i
+      return false unless after.positive?
+
+      ctrl = active_cancel_controller
+      return false unless ctrl
+      return steer_cut!(ctrl, source.to_s) if @generation_phase.cuttable?(after)
+
+      Log.info(:turn, "steer_cut_waits", source: source.to_s) if @waiting_steer.wait!(source, epoch: epoch)
+      false
+    rescue StandardError
+      false
+    end
+
+    # The drains that took input so far (WaitingSteer#epoch): read it before
+    # queueing a message for #cut_for_steer.
+    def input_epoch
+      @waiting_steer.epoch
+    end
+
+    # A thinking chunk streamed: a waiting message cuts once the thinking
+    # passes steer.cut_after.
+    def recheck_waiting_steer
+      return unless @waiting_steer.waiting?
+
+      after = Config.get("steer.cut_after").to_i
+      return unless after.positive? && @generation_phase.cuttable?(after)
+
+      source = @waiting_steer.take
+      ctrl = active_cancel_controller
+      steer_cut!(ctrl, source, waited: true) if source && ctrl
+    rescue StandardError
+      nil
+    end
+    private :recheck_waiting_steer
+
+    def steer_cut!(ctrl, source, waited: false)
+      age = @generation_phase.age
+      cut = ctrl.cancel_generation!(:steer, { by: "steer", steer: true, source: source, reason: "a new message" })
+      if cut
+        @waiting_steer.clear!
+        fields = { source: source, age: age&.round(1) }
+        fields[:waited] = true if waited
+        Log.info(:turn, "steer_cut", **fields)
+      end
+      cut
+    end
+    private :steer_cut!
+
     # Like #steer, for the turn that begins next (a continue turn answered
     # with a text): it joins that turn at its first boundary. Callable from
     # any thread; a turn that never begins keeps it for the next one, unless
@@ -344,10 +413,13 @@ module Samagotchi
     # in a --non-interactive run) and the plugin steers. At the after-answer
     # boundary the steers are dropped: the model answered, and a nudge would
     # only restart the turn. The steer part fails on its own, never taking
-    # the user's lines with it.
+    # the user's lines with it. Items are a String (a user line), a
+    # Steer::Line (a worker's input line with its sender) or a steer Hash.
     def turn_drain(pending_input)
       lambda do |at_answer: false|
         lines = pending_input ? Array(pending_input.call) : []
+        # The input went to the model: a message that waited to cut is in.
+        @waiting_steer.delivered! unless lines.empty?
         lines + take_steers(at_answer)
       end
     end
@@ -1883,6 +1955,8 @@ module Samagotchi
       # shared inactivity clock so the idle recap detector (shared with the REPL)
       # treats the just-finished turn as activity and re-arms its window.
       left = @turn_state.finish!
+      @generation_phase.finished!
+      @waiting_steer.clear!
       Client.swap_probe_cancel(probe_cancel_before)
       # The next turn's window and served model are asked again: the cache
       # (this host's, process-wide) is dropped here, at the turn's end,
@@ -2331,11 +2405,16 @@ module Samagotchi
         progress = nil
         case event[:type]
         when :generation_started
+          @generation_phase.started!
           watch&.started(event[:iteration])
         when :generation_chunk
           # A chunk without the lanes (no loop of ours sends one) counts as text.
           text = event.key?(:text) ? event[:text] : event[:content]
           progress = { thinking: event[:thinking].to_s, text: text.to_s }
+          @generation_phase.chunk!(**progress, tool_call: event[:tool_call])
+          recheck_waiting_steer unless progress[:thinking].empty?
+        when :generation_retrying then @generation_phase.retrying!
+        when :generation_completed, :generation_cancelled then @generation_phase.finished!
         end
         # The chat loop asked again without the thinking fields: a notice,
         # not an event of its own.

data/lib/samagotchi/generation_phase.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # What the running generation is doing, as the Engine's stream handler
+  # sees it: whether a steer may cut it (Engine#cut_for_steer). A
+  # generation is cuttable while it has only been thinking: it streamed
+  # thinking, still streams it (a thinking delta in the last FRESH_SECONDS),
+  # and has streamed no visible text and no tool call. Its age counts from
+  # its first thinking delta, so the wait for a first token (a busy or
+  # remote server) never counts as thinking. Fed from the stream
+  # thread, read from a steer's thread: its own Mutex, never held while
+  # calling out.
+  class GenerationPhase
+    # A thinking delta this recent means the model is still thinking.
+    FRESH_SECONDS = 2.0
+
+    # @param clock [#call] monotonic seconds
+    def initialize(clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+      @clock = clock
+      @mutex = Mutex.new
+      @running = false
+      clear_seen
+    end
+
+    # A generation began.
+    def started!
+      @mutex.synchronize do
+        @running = true
+        clear_seen
+      end
+    end
+
+    # One streamed chunk's lanes. Blank text (a stray newline before Gemma's
+    # thought channel) is no text.
+    def chunk!(thinking:, text:, tool_call: false)
+      @mutex.synchronize do
+        unless thinking.to_s.empty?
+          @thinking_at = @clock.call
+          @thinking_since ||= @thinking_at
+        end
+        @text = true unless text.to_s.strip.empty?
+        @tool_call = true if tool_call
+      end
+    end
+
+    # The request is sent again (a network retry): it streams from the
+    # start, so what it had seen (its thinking clock too) is forgotten.
+    def retrying!
+      @mutex.synchronize { clear_seen }
+    end
+
+    # The generation ended (completed, cut, cancelled, or the turn ended).
+    def finished!
+      @mutex.synchronize { @running = false }
+    end
+
+    # Whether a steer may cut the running generation: thinking only, still
+    # thinking, and thinking for at least +min_age+ seconds.
+    def cuttable?(min_age)
+      @mutex.synchronize do
+        next false unless @running && @thinking_since && !@text && !@tool_call
+
+        now = @clock.call
+        now - @thinking_at <= FRESH_SECONDS && now - @thinking_since >= min_age
+      end
+    end
+
+    # Seconds since the running generation's first thinking delta; nil
+    # with none.
+    def age
+      @mutex.synchronize { @running && @thinking_since ? @clock.call - @thinking_since : nil }
+    end
+
+    private
+
+    def clear_seen
+      @thinking_since = nil
+      @thinking_at = nil
+      @text = false
+      @tool_call = false
+    end
+  end
+end