samagotchi 0.138.0 → 0.139.1

data/lib/samagotchi/bundles/mcp/plugin.rb

@@ -454,10 +454,15 @@ class Plugin
     client
   end
 
-  # A server's env: the session's project env (the worker's mise env, on a
-  # chi that has it: Samagotchi::ProjectEnv) under the server's own keys.
+  # A server's env: the session's project env as execute's commands get it
+  # (the worker's mise env without chi's own Ruby and Bundler setup, on a
+  # chi that has it: Samagotchi::ProjectEnv.spawn_env) under the server's
+  # own keys. An older chi has only the overlay, or none.
   def server_env(server)
-    project = defined?(Samagotchi::ProjectEnv) ? Samagotchi::ProjectEnv.current.env : {}
+    project = if !defined?(Samagotchi::ProjectEnv) then {}
+              elsif Samagotchi::ProjectEnv.respond_to?(:spawn_env) then Samagotchi::ProjectEnv.spawn_env
+              else Samagotchi::ProjectEnv.current.env
+              end
     project.merge(server.env)
   end
 

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.138.0
+version: 0.139.1
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:df3f8da539a9f5812f79e089c2c8b9894da6124a89654f292160046a6bb060da
+  self_map.md: sha256:3253cb9ae7f09821d8fe1fed5154dd2b5e33fe0e9f096eee2af981d7d7d66f16
   config_modification_protocol.md: sha256:ff4efccf2bdde453fc4e6741df8c18f78da78e353f6b1a5a64d0e7a631aea258
   memory_guide.md: sha256:3b9ff779ee962f1307d56937c826d5e581923114f3f39455b779ca618b363cd7
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

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

@@ -31,8 +31,8 @@
   asking for changes, checks failing, the PR closed), chi may start a turn for it with no user
   message ("context <name> changed"): I tell my user what changed and act on nothing.
 - `[TASK FINISHED from task <id8>, …]` is a background task I started (`task_create`, an `execute`
-  handed over at its limit) that finished while I wasn't waiting on it: its exit code, duration
-  and log tail. When it opens a turn with no user message ("task <id8> finished"), I carry on with
+  handed over at its limit, or early when a message came for my turn) that finished while I wasn't
+  waiting on it: its exit code, duration and log tail. When it opens a turn with no user message ("task <id8> finished"), I carry on with
   what I planned for its result, or tell my user in a sentence or two how it went. Without the
   "chi started this turn" line it is only information for my next answer.
 - `forget_outputs` (only when my model's `llm_context.strategy` has the experimental forget layer)

data/lib/samagotchi/cancellation_controller.rb

@@ -20,8 +20,8 @@ module Samagotchi
       @generation = nil
     end
 
-    # @param detail [Object, nil] what the canceller says about it (a cut
-    #   generation's {by:, reason:})
+    # @param detail [Object, nil] what the canceller says about it (the Cut
+    #   of a cut generation, or a turn stopped by a hook)
     def cancel!(reason = :manual, detail = nil)
       listeners = []
       @mutex.synchronize do
@@ -54,11 +54,11 @@ module Samagotchi
       @mutex.synchronize { @detail }
     end
 
-    # Who stopped it when a hook did: the detail's +by+ (the bundle, or the
+    # Who stopped it when a hook did: the Cut's +by+ (the bundle, or the
     # hook's label); nil for any other cancel.
     def stopped_by
       reason, detail = @mutex.synchronize { [@reason, @detail] }
-      by = detail[:by].to_s if reason == :hook && detail.is_a?(Hash)
+      by = detail.by.to_s if reason == :hook && detail.respond_to?(:by)
       by unless by.nil? || by.empty?
     end
 

data/lib/samagotchi/config.rb

@@ -293,6 +293,10 @@ module Samagotchi
       Entry.new(key: "update.bundles",           yaml_path: %w[update bundles],           type: :bool,    default: true,            expose: %i[env config], lifecycle: :next_update),
       Entry.new(key: "update.desktop",           yaml_path: %w[update desktop],           type: :bool,    default: true,            expose: %i[env config], lifecycle: :next_update),
       Entry.new(key: "update.notify",            yaml_path: %w[update notify],            type: :enum,    default: "on",             expose: %i[env config], enum_values: %w[on off], lifecycle: :web_start),
+      # Unattended installs (chi web, Web::AutoUpdate): install: the release the checker found, once no turn runs anywhere;
+      # update.restart then says whether idle workers and chi web restart onto it (idle) or it waits for the owner (never).
+      Entry.new(key: "update.auto",              yaml_path: %w[update auto],              type: :enum,    default: "off",            expose: %i[env config], enum_values: %w[off install], lifecycle: :web_start),
+      Entry.new(key: "update.restart",           yaml_path: %w[update restart],           type: :enum,    default: "idle",           expose: %i[env config], enum_values: %w[idle never], lifecycle: :web_start),
       Entry.new(key: "update.check_hours",       yaml_path: %w[update check_hours],       type: :integer, default: 24,               expose: %i[env config], lifecycle: :web_start,
                 check: ->(value) { "at least 1" unless value >= 1 }),
       Entry.new(key: "update.min_age_hours",     yaml_path: %w[update min_age_hours],     type: :integer, default: 24,               expose: %i[env config], lifecycle: :web_start,

data/lib/samagotchi/context_fetch.rb

@@ -109,8 +109,8 @@ module Samagotchi
 
     def env_for(location, name)
       previous = location.snapshot_path(name)
-      # The session's project env (ProjectEnv) under the source's own keys.
-      ProjectEnv.tools_env.merge("SAMAGOTCHI_CONTEXT_NAME" => name,
+      # The session's project env (ProjectEnv.spawn_env) under the source's own keys.
+      ProjectEnv.spawn_env.merge("SAMAGOTCHI_CONTEXT_NAME" => name,
                                  "SAMAGOTCHI_CONTEXT_PREVIOUS" => File.exist?(previous) ? previous : nil)
     end
 

data/lib/samagotchi/cut.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Why a generation was cut: what CancellationController#cancel_generation!
+  # is given (a bundle's stop_generation, or Engine#cut_for_steer) and what
+  # the loops keep on a cut generation. +by+ is who stopped it (the hook's
+  # label, or "steer"), +reason+ what it said, +steer+ true when a queued user
+  # message cut it (no nudge, no retry attempt spent), +source+ that message,
+  # for the steer_cut row. The same value rides a whole-turn stop
+  # (stop_turn): the cancel note reads its +by+ and +reason+.
+  Cut = Data.define(:by, :reason, :steer, :source) do
+    def initialize(by: nil, reason: nil, steer: false, source: nil) = super
+
+    # A hook's cut (stop_generation, or stop_turn): the bundle +by+ and its
+    # +reason+.
+    def self.hook(by: nil, reason: nil) = new(by: by, reason: reason)
+
+    # Engine#cut_for_steer: a queued message cut the streaming generation.
+    def self.steer(source) = new(by: "steer", reason: "a new message", steer: true, source: source)
+  end
+end

data/lib/samagotchi/cut_policy.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "cut"
 require_relative "turn_note"
 
 module Samagotchi
@@ -30,7 +31,7 @@ module Samagotchi
 
     module_function
 
-    # +cut+: the cut's detail (the stop_generation payload). +emit+ takes an
+    # +cut+: the Cut (what stop_generation passed). +emit+ takes an
     # event Hash; +inject+ puts queued input in (true when there was any).
     # +finish_reason+ and +thinking_chars+: the cut generation's, for the
     # retry's row.
@@ -40,13 +41,13 @@ module Samagotchi
       return STOPPED if cancel_controller.cancelled?
 
       # The row under the cut step, above the message it was cut for.
-      emit.call({ type: :steer_cut, iteration: iteration, source: cut[:source].to_s }) if cut[:steer]
-      return AGAIN if inject.call || cut[:steer]
+      emit.call({ type: :steer_cut, iteration: iteration, source: cut.source.to_s }) if cut.steer
+      return AGAIN if inject.call || cut.steer
 
       if empty_retry.left?
-        empty_retry.nudge!(conversation, TurnNote.cut_retry(cut[:by], cut[:reason]),
+        empty_retry.nudge!(conversation, TurnNote.cut_retry(cut.by, cut.reason),
                            emit: emit, iteration: iteration, finish_reason: finish_reason,
-                           thinking_chars: thinking_chars, stopped_by: cut[:by])
+                           thinking_chars: thinking_chars, stopped_by: cut.by)
         return AGAIN
       end
       empty_retry.drop_nudge!(conversation)

data/lib/samagotchi/engine.rb

@@ -671,7 +671,8 @@ module Samagotchi
     end
 
     # Whether a message a person sent waits for the running turn's next
-    # boundary (run_turn's input_waiting: probe): a task_wait returns on it
+    # boundary (run_turn's input_waiting: probe): a task_wait or delegate wait
+    # returns on it, an execute hands its command over early
     # (PeerView#input_waiting?). False outside a turn, for a turn given no
     # probe, and when the probe raises (warned once a turn; the tool never
     # fails for it).
@@ -2242,7 +2243,8 @@ module Samagotchi
     #   by the agentic loop at iteration boundaries (see KernelLoop#run).
     # @param input_waiting [#call, nil] optional probe: true while a message
     #   a person sent waits for the next boundary (it peeks, never drains);
-    #   a running task_wait returns on it (#input_waiting?). nil: never.
+    #   a running task_wait or delegate wait returns on it, a running execute
+    #   hands its command over (#input_waiting?). nil: never.
     # @param continue [Boolean] resume the conversation without appending a
     #   user prompt (continue after the iteration limit, reminder turns);
     #   +prompt+ is ignored and :turn_started carries `continue: true`

data/lib/samagotchi/engine_peers.rb

@@ -9,7 +9,8 @@ module Samagotchi
     # is the running turn's cancel, for a tool that waits (delegate_result):
     # the controller is set from another thread and a tool gets no other
     # way to see it. input_waiting? is whether a person's message waits for
-    # the running turn's next boundary (task_wait returns on it).
+    # the running turn's next boundary (task_wait and the delegate tools' waits
+    # return on it, execute hands its command over early).
     PeerView = Struct.new(:engine) do
       def session_id = engine.session&.id
       def cwd = engine.session&.working_directory

data/lib/samagotchi/hook_routes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "cut"
 require_relative "event_routes"
 require_relative "hooks"
 require_relative "log"
@@ -104,7 +105,7 @@ module Samagotchi
       return false unless ctrl && !ctrl.cancelled?
 
       notify("stopped the turn: #{reason}", :warn, hook)
-      ctrl.cancel!(:hook, { by: source(hook), reason: reason.to_s })
+      ctrl.cancel!(:hook, Cut.hook(by: source(hook), reason: reason.to_s))
     end
 
     # Cut the streaming generation (reason :hook); the turn goes on and asks
@@ -115,7 +116,7 @@ module Samagotchi
       ctrl = @cancel_controller.call
       return false unless ctrl
 
-      ctrl.cancel_generation!(:hook, { by: source(hook), reason: reason.to_s })
+      ctrl.cancel_generation!(:hook, Cut.hook(by: source(hook), reason: reason.to_s))
     end
 
     private

data/lib/samagotchi/kernel_loop.rb

@@ -13,6 +13,7 @@ require_relative "client"
 require_relative "llm/errors"
 require_relative "log"
 require_relative "empty_answer_retry"
+require_relative "cut"
 require_relative "cut_policy"
 require_relative "thinking"
 require_relative "hooks"
@@ -327,8 +328,9 @@ module Samagotchi
     # One request: the prompt and its images as sent, the images' token
     # estimate, and the window it was measured against.
     Request = Struct.new(:prompt, :images, :image_tokens, :window, :prefill, keyword_init: true)
-    # One generation: the response (nil when cut), the cut's detail, this
-    # generation's own server counts, the model the server named, the
+    # One generation: the response (nil when cut), the Cut that stopped it
+    # (an empty one when nothing said why), this generation's own server
+    # counts, the model the server named, the
     # thinking it streamed, and why it stopped (llama.cpp's finish
     # reason, Client.finish_reason_from; nil when not named),
     # and its prompt-cache counts (the largest seen: they come cumulative),
@@ -472,7 +474,7 @@ module Samagotchi
       rescue Client::RequestCancelled
         raise unless cut?(generation_controller, turn.cancel_controller)
 
-        generation.cut = generation_controller.detail || {}
+        generation.cut = generation_controller.detail || Cut.new
         nil
       end
       generation.cut ? cut_generation(turn, generation, buffer_mark) : completed_generation(turn, request, generation)
@@ -634,8 +636,8 @@ module Samagotchi
       turn.buffer.slice!(buffer_mark..)
       emit(turn, type: :generation_completed, iteration: turn.iteration, content_length: 0,
                  thinking_chars: generation.streamed_thinking, served_model: generation.served_model,
-                 requested_model: turn.model_name, finish_reason: "stopped", stopped_by: generation.cut[:by],
-                 stop_reason: generation.cut[:reason])
+                 requested_model: turn.model_name, finish_reason: "stopped", stopped_by: generation.cut.by,
+                 stop_reason: generation.cut.reason)
     end
 
     def completed_generation(turn, request, generation)
@@ -668,7 +670,7 @@ module Samagotchi
       raise Client::RequestCancelled, turn.cancel_controller.reason if outcome.stopped?
       return :next if outcome.again?
 
-      emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: :hook, stopped_by: cut[:by])
+      emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: :hook, stopped_by: cut.by)
       cancelled_result(turn.conversation, tool_activity: turn.tool_activity, reason: :hook, partial_assistant_text: "")
     end
 

data/lib/samagotchi/launch_mode.rb

@@ -17,8 +17,11 @@ module Samagotchi
     # into a kept one.
     SCRATCH_LEFTOVER = "that's a leftover scratch session; it is deleted at the next sweep (chi sessions clean)"
     # A worker spawned or resumed for an attach whose Bridge never came (%s:
-    # the session id).
-    BRIDGE_LATE = "the worker for session %s did not start its Bridge in time"
+    # the session id). A worker whose chi home couldn't load chi logs
+    # SessionManager::HOME_BOOT_FAILED and exits: HomeDoctor's boot row says
+    # what and what to run, so the text names chi home doctor.
+    BRIDGE_LATE = "the worker for session %s did not start its Bridge in time " \
+                  "(chi home doctor shows a worker that failed to boot)"
     # An attach (or a resume) that found the session's worker leaving, its
     # Bridge closed and its recap on leave still being written: it waits for
     # the worker to let go (OwnerLock.await_release), then starts a new one.

data/lib/samagotchi/llm/chat_loop.rb

@@ -14,6 +14,7 @@ require_relative "stream_drops"
 require_relative "../kernel_loop"
 require_relative "../answer_display"
 require_relative "../answer_refs"
+require_relative "../cut"
 require_relative "../cut_policy"
 require_relative "../context_status"
 require_relative "../context_window"
@@ -763,7 +764,7 @@ module Samagotchi
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
 
-            return cut_response(iteration, thought, generation_controller.detail || {})
+            return cut_response(iteration, thought, generation_controller.detail || Cut.new)
           end
           dropped = settle_thinking_drop(iteration, response.thinking_drop)
           record_context_status(response.usage, window)
@@ -820,7 +821,7 @@ module Samagotchi
         # stream never sent its last chunk).
         def cut_response(iteration, thought, cut)
           emit(type: :generation_completed, iteration: iteration, content_length: 0, thinking_chars: thought.length,
-               requested_model: @model_name, finish_reason: "stopped", stopped_by: cut[:by], stop_reason: cut[:reason])
+               requested_model: @model_name, finish_reason: "stopped", stopped_by: cut.by, stop_reason: cut.reason)
           response = ChatResponse.new(text: "", reasoning: thought, tool_calls: [], usage: nil, finish_reason: "stopped",
                                       cut: cut)
           [response, nil]

data/lib/samagotchi/llm/openai_chat.rb

@@ -26,7 +26,7 @@ module Samagotchi
     # +provider+ is the provider that served it (the body's `provider`,
     # OpenRouter's routing name); nil when the server says nothing.
     # +cut+ is set on the empty response the chat loop makes for a
-    # generation a plugin cut (stop_generation): {by:, reason:}.
+    # generation a plugin cut (stop_generation): the Cut.
     # +top_logprobs+: the first answer token's likeliest alternatives
     # (TokenLogprob) when the request asked for logprobs and the server
     # sent them (a non-streamed answer only); [] otherwise.

data/lib/samagotchi/memory_bundle/status.rb

@@ -12,6 +12,16 @@ require_relative "../model_overlay"
 module Samagotchi
   module MemoryBundle
     module Status
+      # A bundle as this chi reads it now (what chi bundle status prints):
+      # its stored record, the scope it resolves to (scope_error when it
+      # can't), the folder its files belong in, what each file looks like on
+      # disk, its installed plugin, why none of its hooks load, and its needs
+      # with what this process's PATH found. The +files+ entries and +plugin+
+      # stay Hashes: their fields differ per case (an unchecked file has no
+      # paths at all).
+      Report = Data.define(:provenance, :scope, :scope_error, :target_dir, :files, :plugin,
+                           :hooks_requires_failure, :needs)
+
       # A scope this chi can't resolve (a newer chi's, a hand edit) isn't
       # guessed: scope_error says so, target_dir is nil and each file is
       # unchecked (no disk reads, nothing counted as missing).
@@ -50,9 +60,9 @@ module Samagotchi
             base_path: base_path
           }
         end
-        { provenance: bundle, scope: scope, scope_error: target_dir ? nil : "unknown scope: #{scope}",
-          target_dir: target_dir, files: details, plugin: plugin_status(provenance, bundle),
-          hooks_requires_failure: hooks_requires_failure(bundle), needs: needs_status(bundle) }
+        Report.new(provenance: bundle, scope: scope, scope_error: target_dir ? nil : "unknown scope: #{scope}",
+                   target_dir: target_dir, files: details, plugin: plugin_status(provenance, bundle),
+                   hooks_requires_failure: hooks_requires_failure(bundle), needs: needs_status(bundle))
       end
 
       # Why none of the bundle's hooks load (this chi doesn't meet its

data/lib/samagotchi/project_env.rb

@@ -50,8 +50,10 @@ module Samagotchi
     # Keys the tools' overlay never sets: a `chi` a tool runs (the shim's)
     # reads its config, state and log dirs, its settings and the machine its
     # session commands go to (CHI_REMOTE) from them, and the test-run flags.
-    # Dropped, with one warning.
-    RESERVED_KEYS = %w[HOME RACK_ENV CI CHI_REMOTE].freeze
+    # And TMPDIR: the guardrails judge a tool's `$TMPDIR/x` and its tmp dirs
+    # (Guardrails::PathResolve.tmp_roots) by the worker's own TMPDIR, so the
+    # tools must run on that one too. Dropped, with one warning.
+    RESERVED_KEYS = %w[HOME TMPDIR RACK_ENV CI CHI_REMOTE].freeze
     RESERVED_PREFIXES = %w[XDG_ SAMAGOTCHI_].freeze
     # Never set from an ORIG_ENV record (a tool can write it), only unset:
     # loader and Bundler variables.
@@ -112,6 +114,18 @@ module Samagotchi
     # @return [Hash{String=>String, nil}]
     def tools_env = current.env.except(*TOOLS_DROP)
 
+    # The whole env change for a command chi starts for the session outside
+    # execute (MCP servers, context sources): what execute spawns over
+    # (Tools::TaskRuntime.sanitized_spawn_env: chi's own RUBYOPT without
+    # bundler/setup, no RUBYLIB or Bundler variables), then #tools_env. One
+    # env for every command, so a worker run from a checkout under `bundle
+    # exec` hands none of them its Gemfile.
+    # @return [Hash{String=>String, nil}]
+    def spawn_env
+      require_relative "tools/task_runtime" # lazily: bin/chi loads this file for #take_orig!
+      Tools::TaskRuntime.sanitized_spawn_env.merge(tools_env)
+    end
+
     # Specs: back to NONE.
     def reset! = @current = NONE
 

data/lib/samagotchi/reply_wait/poll.rb

@@ -16,12 +16,13 @@ module Samagotchi
     # them. ReplyWait.call's parameters say what each means.
     class Poll
       def initialize(id, state_dir:, cursor:, timeout:, poll_interval:, cancelled:, baseline:, owner_grace:, interject:,
-                     turn:, queued:, ended_before:, running_look: nil)
+                     turn:, queued:, ended_before:, running_look: nil, message_waiting: -> { false })
         @id = id
         @state_dir = state_dir
         @cursor = cursor
         @poll_interval = poll_interval
         @cancelled = cancelled
+        @message_waiting = message_waiting
         @baseline = baseline
         @owner_grace = owner_grace
         @interject = interject
@@ -80,7 +81,7 @@ module Samagotchi
         follow_merge(session)
         reply(session) || settled_turn(session) || status_end(session) || question(session) || held(session) || canceled ||
           ended_before_reply(session) || ended_before_turn(session) || turn_end(session) || owner_gone(session) ||
-          timed_out
+          message_waiting || timed_out
       end
 
       def look_at_input
@@ -189,6 +190,12 @@ module Samagotchi
 
       def canceled = @cancelled.call ? Result.new(status: :canceled) : nil
 
+      # A person's message waits for the caller's turn (call's
+      # message_waiting:): after every outcome the child can arrive at (a
+      # reply, a question, an end, a gone worker) and a cancel, before the
+      # deadline. The child isn't touched.
+      def message_waiting = @message_waiting.call ? Result.new(status: :message_waiting) : nil
+
       # The turn that ended before this wait (ended_before: chi send --wait
       # with no message, on a session that went idle in the gap between
       # waits): its last_turn still stands, the session is idle, so its end

data/lib/samagotchi/reply_wait.rb

@@ -27,7 +27,8 @@ module Samagotchi
     TURN_IDS_FEATURE = "turn_ids"
 
     # @!attribute status [Symbol] :done, :waiting_for_answer, :no_reply,
-    #   :error, :stopped, :canceled, :timeout or :worker_gone
+    #   :error, :stopped, :canceled, :message_waiting, :timeout or
+    #   :worker_gone
     # @!attribute text [String, nil] the reply (:done) or the worker's error
     #   (:error)
     # @!attribute file [String, nil] the reply's filename, the next cursor
@@ -159,14 +160,19 @@ module Samagotchi
     # @param running_look [RunningLook, nil] the running turn an earlier
     #   call of the same wait saw (its :timeout result's running_look): its
     #   settle ends this call too, as if this call had seen it running
+    # @param message_waiting [#call] true once a person's message waits for
+    #   the caller's turn (Engine#input_waiting?): ends the wait early
+    #   (:message_waiting) when nothing else has, after a cancel, before the
+    #   deadline. The session waited for is never touched.
     # @return [Result]
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
              baseline: nil, owner_grace: nil, interject: nil, turn: nil, queued: false, ended_before: false,
-             running_look: nil)
+             running_look: nil, message_waiting: -> { false })
       Poll.new(id, state_dir: state_dir, cursor: cursor, timeout: timeout, poll_interval: poll_interval,
                    cancelled: cancelled, baseline: baseline, owner_grace: owner_grace, interject: interject, turn: turn,
-                   queued: queued, ended_before: ended_before, running_look: running_look).run
+                   queued: queued, ended_before: ended_before, running_look: running_look,
+                   message_waiting: message_waiting).run
     end
 
     # The session as it was before a message went in (call's baseline:):

data/lib/samagotchi/steer_cut.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "config"
+require_relative "cut"
 require_relative "log"
 require_relative "steer"
 require_relative "generation_phase"
@@ -131,7 +132,7 @@ module Samagotchi
 
     def cut!(ctrl, source, waited: false)
       age = @phase.age
-      cut = ctrl.cancel_generation!(:steer, { by: "steer", steer: true, source: source, reason: "a new message" })
+      cut = ctrl.cancel_generation!(:steer, Cut.steer(source))
       if cut
         @waiting.clear!
         fields = { source: source, age: age&.round(1) }

data/lib/samagotchi/task_finish_note.rb

@@ -21,24 +21,27 @@ module Samagotchi
 
     # @param record [Tools::TaskRecord] the finished task
     # @param limit_sec [Integer, nil] the limit an execute handed it over at
+    # @param early_sec [Integer, nil] the seconds an execute had run when a
+    #   message from the user handed it over before its limit
     # @param wake [Boolean] the wake variant
     # @param cap [Integer] max_tool_output_chars: task_wait's text is cut to
     #   it as ToolRunner cuts the tool's result
     # @return [Hash] the note (ContextNote.message's keys)
-    def note(record, limit_sec:, wake:, cap:, turn_id: nil, now: Time.now)
+    def note(record, limit_sec:, wake:, cap:, early_sec: nil, turn_id: nil, now: Time.now)
       note = { note_id: "task-#{record.id}", source: "task #{short_id(record.id)}", header: ContextNote::TASK_HEADER,
-               text: text(record, limit_sec: limit_sec, wake: wake, cap: cap), created_at: now.iso8601 }
+               text: text(record, limit_sec: limit_sec, early_sec: early_sec, wake: wake, cap: cap), created_at: now.iso8601 }
       wake ? note.merge(turn_start: true, turn_id: turn_id) : note
     end
 
-    def text(record, limit_sec:, wake:, cap:)
-      [headline(record, limit_sec), "command: #{record.command}", body(record, cap), (WAKE_TEXT if wake)].compact.join("\n")
+    def text(record, limit_sec:, wake:, cap:, early_sec: nil)
+      [headline(record, limit_sec, early_sec), "command: #{record.command}", body(record, cap), (WAKE_TEXT if wake)].compact.join("\n")
     end
 
-    def headline(record, limit_sec)
+    def headline(record, limit_sec, early_sec = nil)
       seconds = duration(record)
       outcome = record.exit_code.nil? ? record.status.to_s : "exit #{record.exit_code}"
       handed = " (handed over by execute at its #{limit_sec}s limit)" if limit_sec
+      handed ||= " (handed over by execute after #{early_sec}s: a message from the user was waiting)" if early_sec
       "Background task #{short_id(record.id)} finished: #{outcome}#{" after #{duration_text(seconds)}" if seconds}#{handed}."
     end
 

data/lib/samagotchi/task_watch.rb

@@ -19,12 +19,14 @@ module Samagotchi
   # and anytime commands run on threads of their own.
   class TaskWatch
     # A watched task: +limit_sec+, the limit an execute handed it over at
-    # (nil for task_create's); +note_only+, the user stopped the turn that
+    # (nil for task_create's); +early_sec+, the seconds an execute had run
+    # when a message from the user handed it over early (nil otherwise);
+    # +note_only+, the user stopped the turn that
     # started or waited on it (M5): its finish is a plain note, no wake;
     # +failures+, how often its note couldn't be written (#put_back) or the
     # look for it failed (#look_failed).
-    Entry = Data.define(:id, :limit_sec, :note_only, :failures) do
-      def initialize(id:, limit_sec: nil, note_only: false, failures: 0) = super
+    Entry = Data.define(:id, :limit_sec, :early_sec, :note_only, :failures) do
+      def initialize(id:, limit_sec: nil, early_sec: nil, note_only: false, failures: 0) = super
     end
 
     # A task whose note or look failed this often still gets tried at each
@@ -41,6 +43,7 @@ module Samagotchi
     TASK_LINE = /\A#{Tools::TaskRuntime::RAN_AS_LINE}(?:\[task_(?:wait|get|stop)\]\n)?task_id: (\S+)/
     LOOK_TOOLS = %w[task_wait task_get task_stop].freeze
     HANDED_OVER_LIMIT = /#{Regexp.escape(Tools::Execute::HANDED_OVER)} (\d+)s limit/
+    HANDED_OVER_EARLY = /#{Regexp.escape(Tools::Execute::HANDED_OVER)} (\d+)s mark/
 
     MODE_KEY = "session.task_wakes"
     MODES = %w[wake queue off].freeze
@@ -75,16 +78,18 @@ module Samagotchi
       output = event[:output].to_s
       output = output.scrub unless output.valid_encoding?
       if (id = Tools::TaskRuntime.created_id(tool, output))
-        add(id, limit_sec: tool == Tools::Execute::NAME ? output[HANDED_OVER_LIMIT, 1]&.to_i : nil)
+        executed = tool == Tools::Execute::NAME
+        add(id, limit_sec: executed ? output[HANDED_OVER_LIMIT, 1]&.to_i : nil,
+                early_sec: executed ? output[HANDED_OVER_EARLY, 1]&.to_i : nil)
       elsif LOOK_TOOLS.include?(tool) && (id = output[TASK_LINE, 1])
         touched(id)
         remove(id) if seen?(tool, output)
       end
     end
 
-    def add(id, limit_sec: nil)
+    def add(id, limit_sec: nil, early_sec: nil)
       @mutex.synchronize do
-        @entries[id] = Entry.new(id: id, limit_sec: limit_sec)
+        @entries[id] = Entry.new(id: id, limit_sec: limit_sec, early_sec: early_sec)
         @turn_ids << id
       end
     end

data/lib/samagotchi/testing/boundary.rb

@@ -103,7 +103,9 @@ module Samagotchi
           "Samagotchi::TokenUsage::CHARS_PER_TOKEN" => "estimates a tool's tokens: could be a stable constant",
           'require "samagotchi/tool_declarations"' => "loaded for Api.tool_spec's schemas",
           "Samagotchi::ProjectEnv" => "checks the worker has a project env (an older chi doesn't)",
-          "Samagotchi::ProjectEnv.current" => "starts a server in the session's project env: needs a ctx tools-env API"
+          "Samagotchi::ProjectEnv.current" => "starts a server in the session's project env: needs a ctx tools-env API",
+          "Samagotchi::ProjectEnv.respond_to?" => "checks the worker has ProjectEnv.spawn_env (an older chi doesn't)",
+          "Samagotchi::ProjectEnv.spawn_env" => "starts a server in the session's project env: needs a ctx tools-env API"
         },
         "slow-commands" => {
           'require "samagotchi/guardrails/shell_lex"' => "for ShellLex",

data/lib/samagotchi/tool_activity.rb

@@ -264,8 +264,8 @@ module Samagotchi
       "ok"
     end
 
-    # An execute still running at its limit, handed over as a task
-    # (Tools::Execute::HANDED_OVER).
+    # An execute still running at its limit (or when a message from the user
+    # waited), handed over as a task (Tools::Execute::HANDED_OVER).
     def handed_over?(tool_name, text)
       return false unless tool_name == Tools::Execute::NAME && text.to_s.start_with?(Tools::Execute::HANDED_OVER)
 
@@ -273,7 +273,7 @@ module Samagotchi
       text.to_s.each_line.first.to_s.scrub.match?(HANDED_OVER_START)
     end
 
-    HANDED_OVER_START = /\A#{Regexp.escape(Tools::Execute::HANDED_OVER)} \d+s limit:/
+    HANDED_OVER_START = /\A#{Regexp.escape(Tools::Execute::HANDED_OVER)} #{Tools::Execute::HANDED_OVER_AFTER}/
 
     def execute_failed?(text)
       code = execute_exit_code(text)

data/lib/samagotchi/tool_declarations.rb

@@ -20,7 +20,7 @@ module Samagotchi
     TOOL_SCHEMAS = [
       {
         name: "execute",
-        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. A command still running at the time limit keeps running as a background task (by default): the result gives its task_id, and task_wait waits for it. Don't background with &; use task_create.",
+        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. A command still running at the time limit, or after a few seconds when a message from the user is waiting, keeps running as a background task (by default): the result gives its task_id, and task_wait waits for it. Don't background with &; use task_create.",
         parameters: {
           type: "object",
           properties: {
@@ -395,7 +395,7 @@ module Samagotchi
       },
       {
         name: "delegate_result",
-        description: "Wait for a delegated child session's next reply, only when this turn can't go on without it: the child named, or this session's newest running child (name the child when a delegate report is about it). After delegate with wait false you don't need this: chi brings each child's reply by itself as a delegate report, also when you are idle, so end your turn or keep working instead of waiting here. A delegate report already carries the reply: don't call this for it. Returns early if the child waits for a question the user must answer. A tool call the child needs approved goes to your user while this waits; the result says how it was answered.",
+        description: "Wait for a delegated child session's next reply, only when this turn can't go on without it: the child named, or this session's newest running child (name the child when a delegate report is about it). After delegate with wait false you don't need this: chi brings each child's reply by itself as a delegate report, also when you are idle, so end your turn or keep working instead of waiting here. A delegate report already carries the reply: don't call this for it. Returns early if the child waits for a question the user must answer, or a message from the user arrives (the child keeps running). A tool call the child needs approved goes to your user while this waits; the result says how it was answered.",
         parameters: {
           type: "object",
           properties: {

data/lib/samagotchi/tools/builtins.rb

@@ -92,6 +92,7 @@ module Samagotchi
         end,
         Execute::NAME => lambda do |call, kctx|
           Execute.call(call[:content], cwd: call[:cwd], cancelled: cancelled_proc(kctx), stop_reason: stop_reason_proc(kctx),
+                                       message_waiting: input_waiting_proc(kctx),
                                        **participant_execute(kctx, project_env(kctx).merge(parent_env(kctx))))
         end,
         RegisterReminder::NAME => lambda do |call, kctx|
@@ -202,7 +203,7 @@ module Samagotchi
 
       # A person's message waits for the turn's next boundary
       # (Engine#input_waiting?, through its PeerView): a task_wait returns on
-      # it. A kernel whose peers can't tell: never.
+      # it, an execute hands its command over early. A kernel whose peers can't tell: never.
       def input_waiting_proc(kctx)
         peers = kctx.peers
         -> { peers.respond_to?(:input_waiting?) && !!peers.input_waiting? }