samagotchi 0.58.0 → 0.60.0

data/lib/samagotchi/engine.rb

@@ -105,17 +105,20 @@ module Samagotchi
     # @param memories           [Array<String>] explicit --memory preload list (merged with the config.yml `memories:` baseline)
     # @param muted_memories     [Array<String>] --mute list: memories hidden from this session (not in the
     #   prompt's index, dropped from the preloads, refused by memory_read); a mute wins over a preload
+    # @param appended_prompt_files [Array<String>] --append-system-prompt's files (absolute paths; a session's
+    #   appended_prompt_files): their text goes into the system prompt after config.yml's append_system_prompt:
     # @param plugins            [Boolean] false: load no bundle plugins (a throwaway Engine for a prompt)
     # @param scratch            [Boolean] a `chi scratch` session: memory writes are refused, and there is no
     #   delegate (a child would outlive it) nor plugin fork
     def initialize(client: nil, host_registry: nil, profile: nil, session_id: nil, no_interrupt: false, model_name: nil, memories: [], muted_memories: [], kernel: nil, recap: nil, reminders: nil,
-                   plugins: true, scratch: false, model_typed: nil)
+                   plugins: true, scratch: false, model_typed: nil, appended_prompt_files: [])
       # The turn as other threads see it (flag, cancel controller, sink,
       # 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 })
       # A message for the running turn cutting its generation.
-      @steer_cut = SteerCut.new(clock: -> { monotonic_now }, controller: -> { active_cancel_controller })
+      @steer_cut = SteerCut.new(clock: -> { monotonic_now }, controller: -> { active_cancel_controller },
+                                cut_after: -> { steer_cut_after })
       @scratch = scratch
       @no_interrupt = no_interrupt
       @chat_backend = nil
@@ -204,7 +207,7 @@ module Samagotchi
       @prompt_builder = SystemPrompt.new(profile: -> { self.profile }, tools: -> { @tools }, session: -> { @session },
                                          thinking: -> { turn_thinking }, model: -> { model_identity },
                                          model_notes: -> { model_notes }, memories: memories,
-                                         muted_memory_names: @muted_memory_names)
+                                         muted_memory_names: @muted_memory_names, appended_files: appended_prompt_files)
       @session = nil
       @session_observer = SessionObserver.new
       @metrics = SessionMetrics.new
@@ -1012,7 +1015,8 @@ module Samagotchi
       snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
                                 served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
                                 thinking: thinking_explained&.summary,
-                                reasoning_history: reasoning_history_explained&.summary, prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
+                                reasoning_history: reasoning_history_explained&.summary, prompt_notes: prompt_notes.map(&:to_h),
+                                prompt_files: @prompt_builder.prompt_files, price_host: target.entry.name)
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1094,6 +1098,29 @@ module Samagotchi
       explained&.source ? explained.label : nil
     end
 
+    # The seconds a cut waits for the effective model to stream only
+    # thinking (SteerCutAfter.resolve), resolved on every call, as
+    # turn_sampling; on any error, the global and its name.
+    # @return [Array(Integer, String|nil)]
+    def steer_cut_after_explained
+      target = @host_registry.resolve(@effective_model_name)
+      SteerCutAfter.resolve(target, names: model_lookup_names(target))
+    rescue StandardError
+      [SteerCut.cut_after, "steer.cut_after"]
+    end
+
+    # #steer_cut_after_explained's seconds: what SteerCut#cut_for_steer
+    # reads, per host and model.
+    def steer_cut_after = steer_cut_after_explained.first
+
+    # "after 60 s (models: qwen)", "never (hosts.splash)" for /model: the
+    # effective model's cut wait and where it came from, nil for the
+    # default.
+    def steer_cut_summary
+      seconds, source = steer_cut_after_explained
+      source ? SteerCutAfter.label(seconds, source) : nil
+    end
+
     # The effective model's thinking level with where it came from and the
     # session's own (SettingExplained), as the next turn resolves it;
     # nil when it can't be resolved.
@@ -1494,7 +1521,7 @@ module Samagotchi
     private :hook_source
 
     # What a notice may stand in for (hook_notify's fallback_for:).
-    NOTICE_FALLBACKS = %i[display].freeze
+    NOTICE_FALLBACKS = %i[display editor].freeze
 
     # One line to the user (:hook_notice). During a turn it is a turn
     # event: the turn's sink (the REPL) and the observers (bridge, log).
@@ -1503,9 +1530,10 @@ module Samagotchi
     #
     # +fallback_for+ names what the line stands in for (NOTICE_FALLBACKS):
     # :display, the answer's display (AnswerDisplay), for a UI that doesn't
-    # render its links. A UI that does leaves the line out; the others, the
-    # log among them, show it. An unknown value is dropped, so the line
-    # shows everywhere.
+    # render its links; :editor, a ref the viewer could open in its editor
+    # (Web::Capabilities#editor), for a UI or a viewer that can't. A UI that
+    # does leaves the line out; the others, the log among them, show it. An
+    # unknown value is dropped, so the line shows everywhere.
     def hook_notify(text, level, hook, fallback_for: nil)
       level = (level || :info).to_sym
       level = :info unless %i[info warn].include?(level)
@@ -1777,8 +1805,14 @@ module Samagotchi
     # +id+: names the turn on :turn_started (its metrics record's id) and on
     # its saved prompt, so a UI pairs the two whatever left the conversation.
     # +limit+: the iteration limit #generate ran it with.
+    # +resumed+: a step-limit Continue (run_turn's resumed:).
+    # +resume_from+: where its reasoning starts, the run it resumes
+    # (run_turn's resume_from:); nil for every other turn, and for a
+    # Continue that starts cold (after a model change).
     Turn = Struct.new(:session, :prompt, :continue, :on_event, :controller, :origin, :started_at, :messages, :ended,
-                      :settings, :id, :limit) do
+                      :settings, :id, :limit, :resumed, :resume_from) do
+      def resumed? = resumed ? true : false
+
       # The turn's boundary events carry the origin only when there is one,
       # so payloads stay unchanged for callers that don't pass it.
       def tag(event) = origin ? event.merge(origin: origin) : event
@@ -1808,6 +1842,14 @@ module Samagotchi
     # @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`
+    # @param resumed [Boolean] a step-limit Continue (with continue:):
+    #   :turn_started carries `resumed: true`, so do the before_turn payload
+    #   and the turn's analytics record. false for every other continue (a
+    #   reminder, a wake).
+    # @param resume_from [Integer, nil] a step-limit Continue's: where the
+    #   run it resumes started (ModelResult#run_start, kept in the offer by
+    #   TurnFlow), so it keeps that run's reasoning; nil starts cold (a
+    #   model change while the offer stood, every other turn).
     # @param origin [Hash, nil] who queued the turn ({client_id:, enqueued_id:});
     #   when given, the turn's boundary events (:turn_started, :turn_completed,
     #   :turn_canceled, :turn_failed) carry it as `origin:`
@@ -1830,9 +1872,13 @@ module Samagotchi
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
     def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false, origin: nil,
-                 images: [], id: nil)
+                 images: [], id: nil, resumed: false, resume_from: nil)
       turn = begin_turn(session, prompt, on_event: on_event, cancel_controller: cancel_controller, origin: origin,
                                          continue: continue, id: id)
+      if continue
+        turn.resumed = resumed
+        turn.resume_from = resume_from
+      end
       begin
         # A Stop cuts the /props probes this thread makes for the turn
         # (window, served model, vision) instead of waiting their timeout.
@@ -1915,7 +1961,9 @@ module Samagotchi
       bind_metrics(session)
       turn_started = { type: :turn_started, session_id: session.id, prompt: turn.prompt, turn_id: turn.id }
       turn_started[:continue] = true if turn.continue
+      turn_started[:resumed] = true if turn.resumed?
       turn_started[:images] = image_refs unless image_refs.empty?
+      turn_started[:cut_after] = steer_cut_after
       emit_event(turn.on_event, turn.tag(turn_started))
       raise image_error if image_error
 
@@ -1955,9 +2003,9 @@ module Samagotchi
       end
 
       # Fire :before_turn hook, with a read-only copy of the history so far
-      # and the prompt (nil on a continue).
+      # and the prompt (nil on a continue); resumed: a step-limit Continue.
       @hooks.fire(:before_turn, { type: :before_turn, session_id: session.id, prompt: turn.prompt,
-                                  messages: hook_messages(session.messages) })
+                                  resumed: turn.resumed?, messages: hook_messages(session.messages) })
 
       turn_messages(turn, image_refs)
       true
@@ -2093,18 +2141,39 @@ module Samagotchi
       log_llm_context(explained)
 
       turn.limit = @no_interrupt ? IterationLimit.for(no_interrupt: true) : max_iterations || IterationLimit.for
-      backend.complete(
+      # Where this run starts (ChatLoop::Run's start): an offer made at its
+      # end keeps it, so a Continue resumes this run.
+      run_start = turn.messages.length
+      reasoning_since = resumed_run_start(turn, run_start)
+      result = backend.complete(
         messages: turn.messages,
         max_iterations: turn.limit,
         on_stream_event: build_stream_event_handler(turn.on_event, cancel_controller: turn.controller),
         cancel_controller: turn.controller,
         model_name: bare_for_backend,
         max_tool_output_chars: max_tool_output_chars,
-        pending_input: turn_drain(pending_input)
+        pending_input: turn_drain(pending_input),
+        reasoning_since: reasoning_since
       )
+      result.run_start = run_start
+      result
     end
     private :generate
 
+    # A step-limit Continue's resume_from, when it is inside the messages the
+    # run gets (a wrong one only drops reasoning: it is ignored, logged).
+    # Entries before it never move between the turns (#turn_messages adds
+    # at the tail, and the system head is replaced in place).
+    def resumed_run_start(turn, run_start)
+      start = turn.resume_from
+      return nil if start.nil?
+      return start if start.is_a?(Integer) && start.between?(0, run_start)
+
+      Log.warn(:turn, "resume_start_invalid", resume_from: start, length: run_start)
+      nil
+    end
+    private :resumed_run_start
+
     # The turn's LLM context strategy and where it came from, in the turn
     # log: when it runs a layer, or the session set it (none too).
     def log_llm_context(explained)
@@ -2178,7 +2247,8 @@ module Samagotchi
     # replace). Runs under the event lock: it also adds the turn's note to
     # result.conversation, which the REPL keeps as-is.
     # A turn that ran out of iterations ends at its tool results, so a
-    # continue resumes from them rather than after a made-up reply.
+    # continue resumes from them rather than after a made-up reply (and a
+    # step-limit Continue from its run's start: ModelResult#run_start).
     def kept_messages(turn, result, seconds)
       conversation = result.conversation if result.conversation.is_a?(Array)
       # Nothing visible (no text) is a turn the model should know ended
@@ -2599,6 +2669,10 @@ module Samagotchi
         state_dir: -> { session_state_dir },
         scratch: -> { @scratch },
         setup: -> { SessionSetup.of(@session) },
+        # The files whose text the built system prompt holds; [] until a
+        # build and after a rebuild that drops them (SystemPrompt#prompt_files
+        # returns [] itself: the || keeps a nil builder safe).
+        prompt_files: -> { @prompt_builder&.prompt_files || [] },
         frontend: -> { interface }
       )
     end

data/lib/samagotchi/host_config.rb

@@ -19,7 +19,7 @@ module Samagotchi
   # describes them, nil when unset; models: {downcased id => HostModel}.
   HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
-                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models) do
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
@@ -50,6 +50,7 @@ module Samagotchi
         vision: ConfigFile.vision_flag(value.call(:vision), where),
         remote: ConfigFile.bool_flag(value.call(:remote), where, "remote"),
         window_tokens: ConfigFile.window_tokens(value.call(:window_tokens), where),
+        steer_cut_after: SteerCutAfter.seconds(value.call(:steer_cut_after), where),
         sampling: ConfigFile.sampling_map(value.call(:sampling), where),
         thinking: Thinking.level(value.call(:thinking), where),
         reasoning_history: ReasoningHistory.level(value.call(:reasoning_history), where),
@@ -170,6 +171,7 @@ module Samagotchi
                      "profile" => profile, "first_token_timeout" => first_token_timeout,
                      "vision" => vision, "sampling" => sampling, "thinking" => thinking&.to_s,
                      "reasoning_history" => reasoning_history&.to_s, "remote" => remote, "window_tokens" => window_tokens,
+                     "steer_cut_after" => steer_cut_after,
                      "llm_context_strategy" => llm_context_strategy&.map(&:to_s),
                      "llm_context_apply" => llm_context_apply&.to_s,
                      "llm_context_budget_tokens" => llm_context_budget_tokens,

data/lib/samagotchi/host_registry.rb

@@ -38,13 +38,14 @@ module Samagotchi
     # reasoning_history: the configured level (ReasoningHistory), nil when unset;
     # remote: the configured true/false (#remote?), nil when unset;
     # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
+    # steer_cut_after: the seconds a cut waits for its thinking (SteerCutAfter), nil when unset;
     # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
-                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models, keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.

data/lib/samagotchi/iteration_limit.rb

@@ -10,8 +10,9 @@ module Samagotchi
   module IterationLimit
     KEY = "turn.max_iterations"
     # A turn's limit unless turn.max_iterations says otherwise, and the
-    # loops' own default.
-    DEFAULT = 100
+    # loops' own default. Loops are caught by the loop-guard bundle and a
+    # long turn shows check-in's card well before it; this catches the rest.
+    DEFAULT = 300
     # A --no-interrupt / --non-interactive turn's, at least: nobody is there
     # to answer a continue offer.
     NO_INTERRUPT = 1000

data/lib/samagotchi/kernel_loop.rb

@@ -204,12 +204,18 @@ module Samagotchi
     #   steering mid-stream); drained lines merge into ONE user message appended
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
+    # @param reasoning_since [Integer, nil] a step-limit Continue's: where the
+    #   run it resumes started in +messages+; that run's model messages keep
+    #   their thought blocks (#prepare_conversation), as within one run. nil:
+    #   every earlier thought is stripped.
     # @return [LLM::ModelResult] final visible response with continuation metadata
-    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+    def run(messages, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil,
+            reasoning_since: nil)
       @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       @last_slot = nil
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
-                                  pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))
+                                  pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars),
+                                  reasoning_since: reasoning_since)
 
       max_iterations.times do |iteration_index|
         turn.iteration = iteration_index + 1
@@ -284,8 +290,8 @@ module Samagotchi
                             :buffer_mark, keyword_init: true)
     private_constant :Turn, :Request, :Generation
 
-    def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:)
-      conversation = prepare_conversation(messages)
+    def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:, reasoning_since: nil)
+      conversation = prepare_conversation(messages, keep_thought_from: thought_floor(messages, reasoning_since))
       context = ContextStatus.new(conversation: conversation, llm_context: @turn_settings.llm_context)
       emit = ->(event) { emit_stream_event(on_stream_event, event) }
       @llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: context, emit: emit)
@@ -992,9 +998,13 @@ module Samagotchi
       @profile.uses_role_prefixes? ? @profile.user_prefix : "#{@profile.turn_start}user\n"
     end
 
-    def sanitize_history(messages)
-      messages.map do |m|
-        if m[:role] == "model"
+    # +keep_thought_from+: model messages from this index on keep their
+    # thought blocks (a resumed run's); nil strips every one.
+    def sanitize_history(messages, keep_thought_from: nil)
+      messages.each_with_index.map do |m, index|
+        if m[:role] == "model" && keep_thought_from && index >= keep_thought_from
+          { role: m[:role], content: m[:content].to_s, display: m[:display] }.compact
+        elsif m[:role] == "model"
           # `display` rides along so the stored conversation keeps it; the
           # prompt formatter never reads it (AnswerDisplay).
           { role: m[:role], content: strip_thought_blocks(m[:content].to_s), display: m[:display] }.compact
@@ -1004,8 +1014,24 @@ module Samagotchi
       end
     end
 
-    # Standard multi-turn compliance: never pass prior raw thought blocks.
-    def prepare_conversation(messages) = sanitize_history(messages)
+    # Standard multi-turn compliance: never pass prior raw thought blocks,
+    # but a resumed run's (+keep_thought_from+, #thought_floor): the same
+    # run going on after a step-limit Continue.
+    def prepare_conversation(messages, keep_thought_from: nil) = sanitize_history(messages, keep_thought_from: keep_thought_from)
+
+    # Where a resumed run's thought blocks start: its start (+since+). Inside
+    # one native run nothing re-sanitizes, so a user entry the run merged (a
+    # steer, a delegate report, the Qwen recovery prompt) left the thoughts
+    # before it in the prompt: they stay. Only a user or turn_start entry
+    # added after the run ended (after its last model message: a !cmd's
+    # output) starts them again past itself. nil without +since+.
+    def thought_floor(messages, since)
+      return nil if since.nil?
+
+      last_reply = messages.rindex { |m| m[:role].to_s == "model" } || -1
+      query = messages.rindex { |m| m[:role].to_s == "user" || m[:turn_start] == true }
+      query && query > last_reply ? [query + 1, since].max : since
+    end
 
     def duplicate_conversation(messages)
       messages.map(&:dup)

data/lib/samagotchi/llm/backend.rb

@@ -14,9 +14,14 @@ module Samagotchi
     # extra surface lives on backend-specific subclasses, never on this interface.
     #
     # The raw-prompt KernelLoop is NativeBackend; the chat loop is ChatLoop.
+    #
+    # +reasoning_since+: where the run a step-limit Continue resumes started
+    # in +messages+ (Engine#run_turn resume_from:); the replies from there on
+    # keep the model's reasoning (thought blocks), as within one run. nil:
+    # the run starts here, as every other turn's does.
     class ModelBackend
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         raise NotImplementedError, "#{self.class}#complete must be implemented"
       end
     end

data/lib/samagotchi/llm/chat_loop.rb

@@ -68,12 +68,14 @@ module Samagotchi
 
       def provider = :chat
 
+      # +reasoning_since+ (ModelBackend#complete): the resumed run's start,
+      # the Run's own start then (#reasoning_boundary).
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         raise ArgumentError, "ChatLoop has no adapter" unless @adapter
 
         conversation = Array(messages).map(&:dup)
-        Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input)
+        Run.new(self, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: reasoning_since)
            .call(max_iterations: max_iterations || 1, cap: KernelLoop.resolve_output_char_cap(max_tool_output_chars))
       rescue StandardError => e
         FailedTurn.attach(e, conversation && plain(conversation))
@@ -195,7 +197,8 @@ module Samagotchi
       # user message: a prompt, a steer, merged input, the chat template's
       # last query; or an entry that starts a turn, turn_start) and +since+
       # (the Run's start, so a continue turn -- a reminder, a context wake,
-      # a continue after a stop -- sends none of the run before it).
+      # a delegate report's wake -- sends none of the run before it; a
+      # step-limit Continue's Run starts where the run it resumes did).
       # @return [Integer, nil]
       def reasoning_boundary(conversation, since: nil, level: reasoning_history)
         case level
@@ -402,7 +405,9 @@ module Samagotchi
       # One turn's state: the conversation, the stream sink and tool
       # activity.
       class Run
-        def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input)
+        # +start+: where the run a step-limit Continue resumes started (nil:
+        # this run starts at the conversation's end).
+        def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input, start: nil)
           @loop = loop
           @conversation = conversation
           @on_stream_event = on_stream_event
@@ -410,8 +415,8 @@ module Samagotchi
           @model_name = model_name
           @pending_input = pending_input
           # Where this run's entries start: the reasoning it sends back
-          # (ChatLoop#reasoning_boundary) is its own.
-          @start = conversation.length
+          # (ChatLoop#reasoning_boundary) is its own, a resumed run's too.
+          @start = start || conversation.length
           @tool_activity = []
           @empty_retry = EmptyAnswerRetry.new
           # The empty generations, never saved: the UIs draw the turn's

data/lib/samagotchi/llm/model_result.rb

@@ -14,9 +14,15 @@ module Samagotchi
     # generations as model messages, which the loops keep out of the
     # conversation) and .empty_retries (the retries spent): the Engine saves
     # them on the turn's note for the UIs (TurnNote.empty).
+    #
+    # .run_start is where the turn's run started in the conversation (the
+    # length of the messages the loop got), set by the Engine after the loop
+    # returns; nil from a loop called directly. A step-limit offer keeps it
+    # (TurnFlow), so a Continue resumes that run (Engine#run_turn resume_from:).
     class ModelResult
       attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
                   :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries
+      attr_accessor :run_start
 
       def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
                      tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0)
@@ -57,8 +63,11 @@ module Samagotchi
         !!pending_tool_calls
       end
 
-      # KernelLoop only marks a run exhausted when it stopped on pending tool
-      # calls, so exhausted? alone already means "resumable".
+      # A run that ran out of iterations can be continued (the step-limit
+      # offer). KernelLoop marks one exhausted only when it stopped on pending
+      # tool calls; ChatLoop also leaves it exhausted when its last iteration
+      # ended in a retry (an empty answer's nudge, a cut) or merged input
+      # after an answer, which a Continue then picks up.
       def resumable?
         exhausted?
       end

data/lib/samagotchi/llm/native_backend.rb

@@ -17,7 +17,7 @@ module Samagotchi
       def provider = :native
 
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
-                   model_name: nil, max_tool_output_chars: nil, pending_input: nil)
+                   model_name: nil, max_tool_output_chars: nil, pending_input: nil, reasoning_since: nil)
         @kernel.run(
           messages,
           max_iterations: max_iterations,
@@ -25,7 +25,8 @@ module Samagotchi
           cancel_controller: cancel_controller,
           model_name: model_name,
           max_tool_output_chars: max_tool_output_chars,
-          pending_input: pending_input
+          pending_input: pending_input,
+          reasoning_since: reasoning_since
         )
       end
     end

data/lib/samagotchi/log_subscriber.rb

@@ -63,7 +63,8 @@ module Samagotchi
       @generation_started_at.clear
       @tool_started_at.clear
       log(:info, :turn_started, session: event[:session_id], prompt_chars: event[:prompt].to_s.length,
-                                continue: event[:continue] || nil, **items(event), **origin(event))
+                                continue: event[:continue] || nil, resumed: event[:resumed] || nil, **items(event),
+                                **origin(event))
     end
 
     def on_turn_completed(event)

data/lib/samagotchi/model_settings.rb

@@ -10,10 +10,11 @@ module Samagotchi
   # downcased key. Each field is nil when unset: profile kept as written
   # (downcased; ModelProfile.resolve validates it), vision true/false,
   # sampling a request-field map, thinking a level, reasoning_history a
-  # ReasoningHistory level, window_tokens, and the
+  # ReasoningHistory level, window_tokens, steer_cut_after whole seconds
+  # (0 = never, SteerCutAfter), and the
   # LLM context strategy, apply rule and budget (LLMContextStrategy). The
   # same per-model fields a hosts: entry carries (HostConfig).
-  ModelSettings = Data.define(:profile, :vision, :sampling, :thinking, :reasoning_history, :window_tokens,
+  ModelSettings = Data.define(:profile, :vision, :sampling, :thinking, :reasoning_history, :window_tokens, :steer_cut_after,
                               :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens) do
     # Every field may be left out (nil).
     def initialize(**fields)
@@ -37,6 +38,7 @@ module Samagotchi
           thinking: Thinking.level(value.call(:thinking), where),
           reasoning_history: ReasoningHistory.level(value.call(:reasoning_history), where),
           window_tokens: ConfigFile.window_tokens(value.call(:window_tokens), where),
+          steer_cut_after: SteerCutAfter.seconds(value.call(:steer_cut_after), where),
           llm_context_strategy: LLMContextStrategy.parse(value.call(LLMContextStrategy::KEY), where),
           llm_context_apply: LLMContextStrategy.parse_apply(value.call(LLMContextStrategy::APPLY_KEY), where),
           llm_context_budget_tokens: LLMContextStrategy.parse_budget(value.call(LLMContextStrategy::BUDGET_KEY), where))

data/lib/samagotchi/plugin/context.rb

@@ -19,7 +19,9 @@ module Samagotchi
     # (chat messages, timeout:, max_tokens:, cancel_controller:) and returns
     # the answer text.
     # +messages_partial+ says whether +messages+ leaves out a running turn;
-    # +model_name+ (the session's resolved model ref, live after /model) and
+    # +prompt_files+ returns the files whose text the built system prompt
+    # holds (SystemPrompt#prompt_files, [] before a build); +model_name+
+    # (the session's resolved model ref, live after /model) and
     # +state_dir+ are what ctx.sessions forks with, and +setup+ (the
     # session's own SessionSetup), which a fork copies; +model_key+ is the
     # model's memory overlay key (ctx.model, ctx.model_key).
@@ -28,8 +30,8 @@ module Samagotchi
     # +frontend+ returns the Engine's interface (:repl, :worker,
     # :non_interactive), which ctx.frontend names for plugins.
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
-                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :steer, :stop_turn, :stop_generation,
-                      :frontend, keyword_init: true)
+                      :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :prompt_files,
+                      :steer, :stop_turn, :stop_generation, :frontend, keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -159,6 +161,17 @@ module Samagotchi
       # a plugin can say what its answer is about.
       def messages_partial? = !!@host.messages_partial&.call
 
+      # The files whose text the session's system prompt holds now, as
+      # absolute paths in prompt order (SystemPrompt#prompt_files): the
+      # AGENTS.md chain (the work tree top down to the cwd), then the
+      # appended files (append_system_prompt:, --append-system-prompt).
+      # [] before the first build and after one that drops them (a model
+      # or tools change). A Host without the member (a spec's) reads [].
+      # @return [Array<String>] frozen
+      def prompt_files
+        Array(@host.prompt_files&.call || []).freeze
+      end
+
       # Run +block+ as this plugin's handler for +event+: until it returns,
       # the helpers called on this thread act as the event's own. Nests (a
       # fire inside a handler gets its own event; the outer one is back

data/lib/samagotchi/process_group.rb

@@ -109,23 +109,96 @@ module Samagotchi
     # TERMs the group, waits up to +grace+ for +stopped+, then KILLs it and
     # waits up to +kill_wait+ for +stopped+ again (a KILL is delivered, not
     # done, when kill returns).
+    #
+    # The groups the group's processes started are stopped with it: a
+    # descendant that moved to a group of its own (GNU `timeout N cmd`
+    # without --foreground calls setpgid) is out of reach of a signal to
+    # +pgid+. They are found (#descendant_groups) before the TERM, while the
+    # group's processes still run, and again before the KILL; each is
+    # signalled too and must be gone as well. One that already lost its
+    # parent (reparented to init: a setsid'd `cmd &` whose shell exited) is
+    # not found, and so left running.
     # @param stopped [#call] true once it has stopped (default: the leader
     #   is gone)
     # @param wait [#call] (seconds) between two checks (default: a sleep)
+    # @param walk [Boolean] also stop the descendants' groups (one ps each
+    #   time, ~40 ms on macOS with ~850 processes)
     # @param signal_options [Hash] for #signal (leader:, quiet:)
     # @return [Boolean] true when it stopped within the grace (no KILL sent)
     # @raise [ArgumentError] unless #signalable?
     def stop(pgid, grace:, poll:, stopped: -> { !alive?(pgid) }, wait: ->(seconds) { sleep(seconds) },
-             kill_wait: KILL_WAIT_SEC, **signal_options)
+             kill_wait: KILL_WAIT_SEC, walk: true, **signal_options)
       check!(pgid)
+      # The group's members only: a leader reaped by now may be another process.
+      extra = walk ? descendant_groups(pgid) : []
       signal(pgid, "TERM", **signal_options)
-      return true if wait_for(stopped, grace, poll, wait)
+      extra.each { |group| signal(group, "TERM") }
+      # +stopped+ is asked until it says true once (it may reap: a second
+      # wait on a reaped pid raises ECHILD), then only the extra groups.
+      done = false
+      all_stopped = -> { (done ||= stopped.call ? true : false) && extra.none? { |group| group_alive?(group) } }
+      return true if wait_for(all_stopped, grace, poll, wait)
 
+      extra |= descendant_groups(pgid) if walk
       signal(pgid, "KILL", **signal_options)
-      wait_for(stopped, kill_wait, poll, wait)
+      extra.each { |group| signal(group, "KILL") }
+      wait_for(all_stopped, kill_wait, poll, wait)
       false
     end
 
+    # Whether any process is still in the group +pgid+.
+    def group_alive?(pgid)
+      check!(pgid)
+      Process.kill(0, -pgid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+
+    # The process groups, other than +pgid+ and chi's own, of the
+    # descendants of the processes in the group +pgid+ (and of the process
+    # +pgid+ itself with +leader+: a leader chi started that left its
+    # group). Read from one `ps -A -o pid=,ppid=,pgid=`; [] when ps fails.
+    # Only members of the group are roots, never the bare pid +pgid+ without
+    # +leader+: a reaped leader's pid may name some other process by now.
+    # @return [Array<Integer>]
+    def descendant_groups(pgid, leader: false)
+      rows = process_table
+      children = rows.group_by { |_pid, ppid, _group| ppid }
+      queue = rows.select { |_pid, _ppid, group| group == pgid }.map(&:first)
+      queue << pgid if leader
+      seen = {}
+      groups = []
+      until queue.empty?
+        pid = queue.shift
+        next if seen[pid]
+
+        seen[pid] = true
+        Array(children[pid]).each do |child, _ppid, group|
+          groups << group unless group == pgid
+          queue << child
+        end
+      end
+      own = Process.getpgrp
+      groups.uniq.select { |group| signalable?(group) && group != own }
+    end
+
+    # Every process as [pid, ppid, pgid].
+    # @return [Array<Array(Integer, Integer, Integer)>]
+    def process_table
+      out, status = Open3.capture2("ps", "-A", "-o", "pid=,ppid=,pgid=", err: File::NULL)
+      return [] unless status.success?
+
+      out.lines.filter_map do |line|
+        fields = line.split.map { |field| Integer(field, exception: false) }
+        fields if fields.size == 3 && fields.all?
+      end
+    rescue SystemCallError, IOError
+      []
+    end
+
     # Checks +stopped+ every +poll+ until it is true or +seconds+ are over.
     # @return [Boolean] whether it stopped
     def wait_for(stopped, seconds, poll, wait)