samagotchi 0.26.0 → 0.28.0

data/lib/samagotchi/llm/prompt_cache.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../config"
+require_relative "../log"
+
 module Samagotchi
   module LLM
     # Prompt-cache breakpoints for Claude models behind an OpenAI-compatible
@@ -17,11 +20,33 @@ module Samagotchi
     # the stable part with the mark, the per-session tail (model, location,
     # session) without, so a new session reads the stable part from the
     # cache. `cache_split:` never goes on the wire (#without_split).
+    #
+    # cache.ttl: 1h marks the breakpoints with `ttl: "1h"` (#control), so a
+    # cache outlives a long reading gap; 5m, the default, sends Anthropic's
+    # default (no ttl).
     module PromptCache
       CONTROL = { type: "ephemeral" }.freeze
+      CONTROL_1H = { type: "ephemeral", ttl: "1h" }.freeze
+      TTLS = %w[5m 1h].freeze
 
       module_function
 
+      # The cache_control a breakpoint carries under cache.ttl (an unknown
+      # value warns once and is 5m).
+      def control
+        value = Config.get("cache.ttl").to_s.strip.downcase
+        return CONTROL_1H if value == "1h"
+
+        unless value.empty? || value == "5m" || @warned_ttl
+          @warned_ttl = true
+          Log.warn(:config, "invalid_value", echo: "Warning: invalid value for cache.ttl: #{value.inspect} (allowed: 5m, 1h) — using 5m",
+                                             key: "cache.ttl")
+        end
+        CONTROL
+      rescue StandardError
+        CONTROL
+      end
+
       # Whether +model+ (the bare id a host is asked for) names a Claude model.
       def claude?(model) = model.to_s.match?(/claude/i)
 
@@ -34,8 +59,9 @@ module Samagotchi
         return without_split(messages) unless claude?(model)
 
         indexes = [system_index(messages), last_index(messages)].compact.uniq
+        breakpoint = control
         messages.each_with_index.map do |message, index|
-          next marked(message.except(:cache_split), split: message[:cache_split]) if indexes.include?(index)
+          next marked(message.except(:cache_split), breakpoint, split: message[:cache_split]) if indexes.include?(index)
 
           message.key?(:cache_split) ? message.except(:cache_split) : message
         end
@@ -80,15 +106,15 @@ module Samagotchi
       # A String becomes one text part (two at +split+, the mark on the
       # first); an Array gets the mark on its last text part (the last part
       # when none is text).
-      def marked(message, split: nil)
+      def marked(message, breakpoint, split: nil)
         content = message[:content]
         if content.is_a?(String)
           if split.is_a?(Integer) && split.positive? && split < content.length
-            return message.merge(content: [{ type: "text", text: content[0, split], cache_control: CONTROL },
+            return message.merge(content: [{ type: "text", text: content[0, split], cache_control: breakpoint },
                                            { type: "text", text: content[split..] }])
           end
 
-          return message.merge(content: [{ type: "text", text: content, cache_control: CONTROL }])
+          return message.merge(content: [{ type: "text", text: content, cache_control: breakpoint }])
         end
 
         target = content.rindex { |part| part.is_a?(Hash) && (part[:type] || part["type"]).to_s == "text" } ||
@@ -96,7 +122,7 @@ module Samagotchi
         part = content[target]
         key = part.key?("type") ? "cache_control" : :cache_control
         parts = content.dup
-        parts[target] = part.merge(key => CONTROL)
+        parts[target] = part.merge(key => breakpoint)
         message.merge(content: parts)
       end
 

data/lib/samagotchi/log.rb

@@ -23,6 +23,8 @@ module Samagotchi
   # (once, until Config.reload!). While that runs (Config can warn itself)
   # records only echo. Nothing here raises into the caller: a record that
   # can't be formatted is dropped, an unwritable file pauses (DebugLog).
+  # The one exception is strict mode (SAMAGOTCHI_LOG_STRICT=1, the spec
+  # suite): an unknown tag or a malformed event raises, whatever the level.
   module Log
     LEVELS = { debug: 0, info: 1, warn: 2, error: 3 }.freeze
     DEFAULT_LEVEL = :info
@@ -39,6 +41,7 @@ module Samagotchi
     @state = nil
     @resolving = false
     @session_id = nil
+    @strict = ENV["SAMAGOTCHI_LOG_STRICT"] == "1"
 
     class << self
       # @param path [String, nil, :auto] the file; :auto → LogPath.resolve
@@ -72,6 +75,9 @@ module Samagotchi
       # carry its first SID_LENGTH chars unless they pass their own sid:.
       attr_accessor :session_id
 
+      # Raise on an unknown tag or a bad event instead of dropping the record.
+      attr_accessor :strict
+
       def debug(tag, event, **kw) = log(:debug, tag, event, **kw)
       def info(tag, event, **kw) = log(:info, tag, event, **kw)
       def warn(tag, event, **kw) = log(:warn, tag, event, **kw)
@@ -96,7 +102,19 @@ module Samagotchi
         resolved_state&.dig(:writer)&.path
       end
 
-      def log(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
+      def log(level, tag, event, **kw)
+        check_names!(tag, event) if strict
+        write_record(level, tag, event, **kw)
+      end
+
+      private
+
+      def check_names!(tag, event)
+        raise ArgumentError, "unknown log tag #{tag}" unless LogLine::TAGS.include?(tag.to_s)
+        raise ArgumentError, "bad log event #{event}" unless event.to_s.match?(LogLine::SLUG)
+      end
+
+      def write_record(level, tag, event, payload: nil, sid: nil, echo: nil, **fields)
         options = @options
         echo_to_stderr(echo) if echo && options.fetch(:stderr, true)
         state = resolved_state
@@ -113,8 +131,6 @@ module Samagotchi
         nil
       end
 
-      private
-
       def build(level, tag, event, payload:, sid:, fields:)
         tag = tag.to_s
         event = event.to_s

data/lib/samagotchi/session.rb

@@ -62,6 +62,15 @@ module Samagotchi
     # "ended_at" => iso8601, "seconds" => Float, "origin" =>
     # "client"|"reminder"|"delegate"}; nil before the first turn.
     attr_accessor :last_turn
+
+    # The hook that stopped the last turn (stop_turn, or a cut with no retry
+    # left), e.g. "loop-guard"; nil when it ended otherwise. Both strings
+    # and symbols are read (the file's keys are strings).
+    def stopped_by
+      return nil unless @last_turn.is_a?(Hash)
+
+      (@last_turn["stopped_by"] || @last_turn[:stopped_by])&.to_s
+    end
     # Archived (ArchiveStore): hidden from the lists. Set by .list (with
     # include_archived); not saved in session.json.
     attr_accessor :archived

data/lib/samagotchi/session_manager.rb

@@ -259,12 +259,13 @@ module Samagotchi
     # @param include_archived [Boolean] archived sessions too
     # @return [Array<Hash>] {id:, short_id:, desc:, preview:, cwd:, project:,
     #   updated_at:, status:, live:, busy:, owner:, recap:, parent_id:,
-    #   parent_short_id:, archived:, scratch:, test_run:, waiting:, waiting_id:}; busy = live with
+    #   parent_short_id:, archived:, scratch:, test_run:, waiting:, waiting_id:, stopped_by:}; busy = live with
     #   a turn running, recap = the saved recap's first sentence, project =
     #   Session#project_root, waiting = the kind of question it waits on
     #   ("question", "approval", "hook"; Session#waiting_question) or nil,
     #   waiting_id = that question's id or nil, relayed_to = the parent
-    #   whose card it waits in too (the approval relay), its short id, or nil
+    #   whose card it waits in too (the approval relay), its short id, or nil,
+    #   stopped_by = the hook that stopped the last turn (Session#stopped_by)
     def self.session_summaries(live: false, cwd: nil, limit: nil, include_tests: true, exclude: nil, state_dir: nil,
                                project_root: nil, include_archived: false, sort: nil, order: nil)
       sd = state_dir || Session.default_state_dir
@@ -284,7 +285,7 @@ module Samagotchi
           owner: owner&.kind, recap: RecapStore.preview(Session.session_dir(s.id, state_dir: sd)),
           ctx_pct: SessionMetrics.saved_context_pct(Session.session_dir(s.id, state_dir: sd))&.round(1),
           parent_id: s.parent_id, parent_short_id: s.parent_id&.[](0, 8), archived: s.archived,
-          scratch: s.scratch, test_run: s.test_run }.merge(waiting_fields(s.waiting_question(live: owned)))
+          scratch: s.scratch, test_run: s.test_run, stopped_by: s.stopped_by }.merge(waiting_fields(s.waiting_question(live: owned)))
       end
       (limit ? summaries.first(limit) : summaries.to_a)
     end

data/lib/samagotchi/sessions_command.rb

@@ -112,6 +112,28 @@ module Samagotchi
       options.to_h { |key, value| [key, INTEGER_OPTIONS.include?(key) ? value.to_i : value] }
     end
 
+    # The flags a list row carries: a chi scratch session, a test run, an
+    # archived one, and the turn's stopper (see #stopped_flag).
+    def session_flag(scratch:, test_run:, archived:, stopped_by: nil)
+      flag = if scratch
+               " [scratch]"
+             else
+               (test_run ? " [test]" : "")
+             end
+      flag += " [archived]" if archived
+      flag + stopped_flag(stopped_by)
+    end
+
+    # The marker for a turn a hook stopped: "[looped]" for loop-guard (the
+    # bundle's thinking watch, and the word `chi sessions stats` uses for its
+    # cuts), "[stopped by X]" for any other hook; "" otherwise. A cut with no
+    # retry left records the same stopped_by.
+    def stopped_flag(by)
+      return "" if by.to_s.empty?
+
+      by.to_s == "loop-guard" ? " [looped]" : " [stopped by #{by}]"
+    end
+
     def list
       format, scope, cwd = @opts.values_at(:format, :scope, :cwd)
       unless format.nil? || %w[text json tsv].include?(format)
@@ -156,7 +178,7 @@ module Samagotchi
         # id, for chi answer --question; relayed_to: the parent session (short
         # id) whose card it also waits in (the approval relay), or nil
         keys = %i[id short_id desc cwd project updated_at live busy owner recap parent_id archived scratch ctx_pct waiting
-                  waiting_id relayed_to]
+                  waiting_id relayed_to stopped_by]
         @stdout.puts JSON.generate(summaries.map { |summary| summary.slice(*keys) })
       when "tsv"
         summaries.each { |summary| @stdout.puts "#{summary[:id]}\t#{summary[:desc]}" }
@@ -176,12 +198,8 @@ module Samagotchi
           end
           # A delegated session points at its parent.
           child = summary[:parent_short_id] ? "  ↳ #{summary[:parent_short_id]}" : ""
-          flag = if summary[:scratch]
-                   " [scratch]"
-                 else
-                   (summary[:test_run] ? " [test]" : "")
-                 end
-          flag += " [archived]" if summary[:archived]
+          flag = session_flag(scratch: summary[:scratch], test_run: summary[:test_run], archived: summary[:archived],
+                              stopped_by: summary[:stopped_by])
           ctx = Samagotchi::SessionMetrics.context_label(summary[:ctx_pct])
           @stdout.puts "#{summary[:id]}  #{state.ljust(8)}  #{ctx.ljust(8)}  #{summary[:updated_at]}  #{desc}#{flag}#{child}"
         end
@@ -209,12 +227,7 @@ module Samagotchi
       end
       # A delegated session points at its parent: ↳ <parent's short id>.
       row = lambda do |s|
-        flag = if s.scratch
-                 " [scratch]"
-               else
-                 (s.test_run ? " [test]" : "")
-               end
-        flag += " [archived]" if s.archived
+        flag = session_flag(scratch: s.scratch, test_run: s.test_run, archived: s.archived, stopped_by: s.stopped_by)
         child = s.parent_id ? "  ↳ #{s.parent_id[0, 8]}" : ""
         # How full the context was after the last turn: "ctx 12%", blank when unknown.
         ctx = Samagotchi::SessionMetrics.context_label(

data/lib/samagotchi/terminal_ui/repl_input.rb

@@ -94,6 +94,19 @@ module Samagotchi
       # @return [Boolean] whether it went in
       def prefill(text) = open? && @reader.prefill(text)
 
+      # What the open prompt holds, nil when none is open: a line typed
+      # ahead there is the next turn's input.
+      def typed_text = @reader&.typed_text
+
+      # Whether the next turn's input is already here: text typed ahead at
+      # the open prompt, or a line a turn took as steering but never merged
+      # (it runs as the next turn).
+      def waiting_input?
+        @lock.synchronize { return true unless @front.empty? }
+
+        !typed_text.to_s.strip.empty?
+      end
+
       # A question answered at the open prompt: the lines submitted from now
       # on go to it, at the ? prompt. What was typed at the prompt is put aside
       # and comes back once the question closes.

data/lib/samagotchi/terminal_ui.rb

@@ -175,6 +175,11 @@ module Samagotchi
       @engine.interface = @non_interactive ? :non_interactive : :repl
       # A --non-interactive run exits after its turn: no turn-end warm-up.
       @engine.next_turn_waiting = -> { true } if @non_interactive
+      # A warm-up never pays off while a line typed ahead at the open prompt
+      # (or a left-over steer) already forms the next turn: only prefill when
+      # the prompt is empty. The REPL-only check composes with the one above.
+      next_waiting = @engine.next_turn_waiting
+      @engine.next_turn_waiting = -> { @repl_input&.waiting_input? || next_waiting&.call }
       @turn_flow = TurnFlow.new(engine: @engine)
       # A recap written while a continue offer waits says the turn stopped
       # unfinished. (Answering at the prompt is typing: activity already.)

data/lib/samagotchi/thinking_tails.rb

@@ -23,7 +23,7 @@ module Samagotchi
   class ThinkingTails
     FILE = "thinking_tails.jsonl"
     # The last chars of a generation's thinking kept: a loop's cycle and
-    # some of its lead-in.
+    # some of its lead-in. TurnNote cuts an empty step's thinking to it too.
     TAIL_CHARS = 20_000
     MAX_RECORDS = 10
 

data/lib/samagotchi/tool_activity.rb

@@ -150,12 +150,13 @@ module Samagotchi
     # "error" for an "Error:" result, and for an execute whose command
     # exited non-zero (its last "exit: N" line; no number: killed by a
     # signal), so the turn tally's "(N failed)" counts it. "stopped" for a
-    # task_wait the user's Stop ended: the task itself runs on.
+    # task_wait the user's Stop ended (the task itself runs on), and for one
+    # whose task was stopped (the stop-task button, or the model's task_stop).
     def tool_activity_status(result, tool_name = nil)
       text = result.to_s
       return "error" if text.start_with?("Error:")
       return "error" if tool_name == Tools::Execute::NAME && execute_failed?(text)
-      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^wait_result: canceled$/)
+      return "stopped" if tool_name == Tools::TaskWait::NAME && text.match?(/^(wait_result: canceled|status: stopped)$/)
 
       "ok"
     end

data/lib/samagotchi/tool_view.rb

@@ -3,6 +3,7 @@
 require_relative "command_steps"
 require_relative "tools/execute"
 require_relative "tools/task_create"
+require_relative "tools/task_wait"
 
 module Samagotchi
   # What a richer UI shows of a tool call beyond its one-line params: the
@@ -18,8 +19,9 @@ module Samagotchi
   # can't (the fallback: the UI shows the command itself) or the command
   # is cut. +description+: what the model said the command does (execute's
   # optional description), whitespace collapsed, a trailing period gone;
-  # nil when it gave none.
-  ToolView = Data.define(:command, :cwd, :truncated, :chars, :cd, :steps, :description) do
+  # nil when it gave none. +task_id+: the task a task_wait waits on (its
+  # only field), for the web's stop-task button.
+  ToolView = Data.define(:command, :cwd, :truncated, :chars, :cd, :steps, :description, :task_id) do
     def to_h = super.merge(steps: steps&.map(&:to_h)).compact.reject { |_key, value| value == false }
   end
 
@@ -37,6 +39,7 @@ module Samagotchi
     # @return [ToolView, nil] nil for a tool without a view and for an
     #   empty command
     def self.for(tool_name, call)
+      return task_wait(call) if tool_name == Tools::TaskWait::NAME && call.is_a?(Hash)
       return nil unless TOOLS.include?(tool_name) && call.is_a?(Hash)
 
       command = call[:content].to_s
@@ -47,9 +50,17 @@ module Samagotchi
       parsed = truncated ? nil : CommandSteps.parse(command)
       new(command: truncated ? command[0, COMMAND_LIMIT] : command, cwd: cwd.empty? ? nil : cwd,
           truncated: truncated, chars: truncated ? command.length : nil, cd: parsed&.cd, steps: parsed&.steps,
-          description: description(call))
+          description: description(call), task_id: nil)
     end
 
+    def self.task_wait(call)
+      task_id = call[:content].to_s.strip
+      return nil if task_id.empty?
+
+      new(command: nil, cwd: nil, truncated: false, chars: nil, cd: nil, steps: nil, description: nil, task_id: task_id)
+    end
+    private_class_method :task_wait
+
     # The call's description as a view shows it, nil for none.
     def self.description(call)
       text = call[:description]

data/lib/samagotchi/tools/task_get.rb

@@ -30,8 +30,9 @@ module Samagotchi
           "finished_at: #{record["finished_at"]}",
           "exit_code: #{record["exit_code"]}",
           "stop_reason: #{record["stop_reason"]}",
-          "output_path: #{record.fetch("output_path")}"
-        ].join("\n")
+          "output_path: #{record.fetch("output_path")}",
+          (TaskRuntime::USER_STOP_NOTE if TaskRuntime.stopped_by_user?(record))
+        ].compact.join("\n")
       end
       private_class_method :format_record
     end

data/lib/samagotchi/tools/task_runtime.rb

@@ -22,6 +22,9 @@ module Samagotchi
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
       MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
+      # task_wait and task_get add it to a task the user stopped (the web's
+      # stop-task button), so the model doesn't rerun the job.
+      USER_STOP_NOTE = "note: the user stopped this task; don't restart it unless they ask."
 
       module_function
 
@@ -107,19 +110,27 @@ module Samagotchi
       # A native tool_response joins its calls' results with "---".
       # @return [Array<Hash>] {id:, command:}, oldest first
       def running_created_in(messages)
-        ids = Array(messages).flat_map do |message|
+        created_ids_in(messages).filter_map do |id|
+          record, _error = get_record(id)
+          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
+        end
+      end
+
+      # The ids of every task this conversation's task_create calls started,
+      # whatever their status now, oldest first.
+      # @return [Array<String>]
+      def created_ids_in(messages)
+        Array(messages).flat_map do |message|
           next [] unless (message[:role] || message["role"]).to_s == "tool_response"
 
           (message[:content] || message["content"]).to_s.split("\n\n---\n\n").filter_map do |block|
             block[/\A\[task_create\]\ntask_id: (\S+)/, 1]
           end
-        end
-        ids.uniq.filter_map do |id|
-          record, _error = get_record(id)
-          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
-        end
+        end.uniq
       end
 
+      def stopped_by_user?(record) = record["stop_reason"] == "stopped_by_user"
+
       def get_record(task_id)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record
@@ -142,13 +153,19 @@ module Samagotchi
         content.lines.last(line_count).join
       end
 
-      def stop_task(task_id)
+      # A requested stop ends as "stopped" whatever the exit code: the flag
+      # is on disk before the TERM, so a reader refreshing the record while
+      # the group dies records the stop, not a failure.
+      # @param by [String] "model" (task_stop) or "user" (the web's button)
+      def stop_task(task_id, by:)
         record = load_record(task_id)
         return [nil, "Error: task not found: #{task_id}"] unless record
 
         refreshed = refresh_record(record)
         return [refreshed, nil] unless refreshed["status"] == "running"
 
+        refreshed["stop_requested_by"] = by.to_s
+        write_record(refreshed)
         pid = refreshed["pid"].to_i
 
         begin
@@ -168,10 +185,7 @@ module Samagotchi
           end
         end
 
-        updated = refresh_record(refreshed)
-        updated["status"] = "stopped" if updated["status"] == "running"
-        updated["finished_at"] ||= timestamp
-        updated["stop_reason"] = "stopped_by_user"
+        updated = mark_stopped(refresh_record(refreshed))
         write_record(updated)
 
         [updated, nil]
@@ -294,9 +308,15 @@ module Samagotchi
       end
 
       def mark_finished_without_exit_code(record)
+        record = current_record(record)
+        return record unless record["status"] == "running"
+
         exit_code = read_exit_code(record["exit_code_path"])
 
-        if exit_code.nil?
+        if record["stop_requested_by"]
+          record["exit_code"] = exit_code
+          mark_stopped(record)
+        elsif exit_code.nil?
           record["status"] = "failed"
           record["exit_code"] = nil
           record["stop_reason"] ||= "process_ended_without_exit_code"
@@ -313,6 +333,23 @@ module Samagotchi
         record
       end
 
+      # The disk copy when it is newer than +record+: already finished, or
+      # flagged by a stop that started after +record+ was read.
+      def current_record(record)
+        disk = load_record(record.fetch("id"))
+        return record unless disk
+        return disk if disk["status"] != "running" || disk["stop_requested_by"]
+
+        record
+      end
+
+      def mark_stopped(record)
+        record["status"] = "stopped"
+        record["stop_reason"] = "stopped_by_#{record["stop_requested_by"]}"
+        record["finished_at"] ||= timestamp
+        record
+      end
+
       def read_exit_code(path)
         return nil if path.to_s.empty? || !File.exist?(path)
 

data/lib/samagotchi/tools/task_stop.rb

@@ -10,7 +10,7 @@ module Samagotchi
       def self.name = NAME
 
       def self.call(task_id)
-        record, error = TaskRuntime.stop_task(task_id.to_s.strip)
+        record, error = TaskRuntime.stop_task(task_id.to_s.strip, by: "model")
         return error if error
 
         [

data/lib/samagotchi/tools/task_wait.rb

@@ -37,10 +37,10 @@ module Samagotchi
           return "Error: #{error}" if error
 
           status = record.fetch("status")
-          return format_response(record) unless status == "running"
+          return finished_response(record, tail_lines) unless status == "running"
 
           if completion_pattern
-            output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+            output_tail = output_tail(record, tail_lines)
             return format_response(record, wait_result: "pattern_matched", output_tail: output_tail) if completion_pattern.match?(output_tail)
           end
 
@@ -53,10 +53,9 @@ module Samagotchi
 
         # Timeout reached — do one final refresh to capture the latest status
         refreshed, = TaskRuntime.get_record(task_id)
-        return format_response(refreshed) unless refreshed.fetch("status") == "running"
+        return finished_response(refreshed, tail_lines) unless refreshed.fetch("status") == "running"
 
-        output_tail = TaskRuntime.output_tail_lines(refreshed.fetch("output_path"), tail_lines)
-        format_response(refreshed, wait_result: "timeout", output_tail: output_tail)
+        format_response(refreshed, wait_result: "timeout", output_tail: output_tail(refreshed, tail_lines))
       rescue StandardError => e
         "Error: #{e.message}"
       end
@@ -66,18 +65,31 @@ module Samagotchi
       def self.cancelled_response(task_id, tail_lines, started)
         record, error = TaskRuntime.get_record(task_id)
         return "Error: #{error}" if error
-        return format_response(record) unless record.fetch("status") == "running"
+        return finished_response(record, tail_lines) unless record.fetch("status") == "running"
 
-        output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
         note = [
           "note: the user stopped the turn while waiting; the task is STILL RUNNING.",
           "  To keep waiting: task_wait #{task_id}. If it is stuck or no longer needed: task_stop #{task_id}.",
           "waited: #{(monotonic_time - started).round}s"
         ]
-        format_response(record, wait_result: "canceled", output_tail: output_tail, extra: note)
+        format_response(record, wait_result: "canceled", output_tail: output_tail(record, tail_lines), extra: note)
       end
       private_class_method :cancelled_response
 
+      # A task the user stopped also says so, with the tail of its output:
+      # the model sees where the job was cut off.
+      def self.finished_response(record, tail_lines)
+        return format_response(record) unless TaskRuntime.stopped_by_user?(record)
+
+        format_response(record, output_tail: output_tail(record, tail_lines), extra: [TaskRuntime::USER_STOP_NOTE])
+      end
+      private_class_method :finished_response
+
+      def self.output_tail(record, tail_lines)
+        TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+      end
+      private_class_method :output_tail
+
       def self.format_response(record, wait_result: nil, output_tail: nil, extra: [])
         lines = [
           "task_id: #{record.fetch("id")}",
@@ -86,9 +98,9 @@ module Samagotchi
           "stop_reason: #{record["stop_reason"]}",
           "output_path: #{record.fetch("output_path")}"
         ]
-        return lines.join("\n") unless wait_result
+        return lines.join("\n") unless output_tail
 
-        lines << "wait_result: #{wait_result}"
+        lines << "wait_result: #{wait_result}" if wait_result
         lines.concat(extra)
         lines << "output_tail:"
         lines << output_tail.rstrip unless output_tail.empty?

data/lib/samagotchi/turn_note.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "model_profile"
+require_relative "thinking_tails"
 
 module Samagotchi
   # The one-line system note a turn leaves in the conversation when it ends
@@ -23,7 +24,8 @@ module Samagotchi
     EMPTY_ANSWER = :empty_answer
     # An empty step's thinking kept on the marker: its tail, so a model
     # that thought for minutes doesn't put megabytes in the session file.
-    STEP_CHARS = 20_000
+    # The same cap as ThinkingTails' saved tails.
+    STEP_CHARS = ThinkingTails::TAIL_CHARS
     # A step's native thinking starts with one of these; the cut keeps it,
     # so the UIs still find the thinking (MessageParts).
     THINK_OPENS = ["<think>", ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN].freeze
@@ -141,7 +143,7 @@ module Samagotchi
     def cut_retry(by, reason)
       why = reason.to_s.strip.empty? ? "" : ": #{one_line(reason)}"
       retry_nudge(message("your last reply was cut off by #{by || "a plugin"}#{why}. Don't start the same reasoning " \
-                          "again; answer the user's last message now, briefly."))
+                          "again; continue the task with your next tool call, or answer if it is done."))
     end
 
     # A retry nudge is marked, so the spent one is found by the mark

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.26.0"
+  VERSION = "0.28.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/vision_context.rb

@@ -66,8 +66,10 @@ module Samagotchi
 
   # Which images of a conversation one request sends. Every image that is
   # not sent becomes a placeholder line: all of them when the model can't
-  # see images, the older ones past limits.max_per_request (the newest go),
-  # and any whose file is gone.
+  # see images, the oldest ones past limits.max_per_request, and any whose
+  # file is gone. Past the limit the oldest images are dropped in batches
+  # (ImagePlan.dropped_count), so the cut stays put for a few new images
+  # and the history before it stays a cacheable prefix.
   class ImagePlan
     Item = Data.define(:ref, :data, :placeholder) do
       def sent? = !data.nil?
@@ -92,7 +94,18 @@ module Samagotchi
         Array(entry[:images]).each_index { |position| occurrences << [index, position] }
       end
       @limit = vision&.limits&.max_per_request || ImageStore::Limits.from_config.max_per_request
-      @sent = occurrences.last(@limit)
+      @sent = occurrences.drop(self.class.dropped_count(occurrences.size, @limit))
+    end
+
+    # How many of +total+ images (oldest first) a request leaves out with
+    # +limit+ per request: none up to the limit, then whole steps of
+    # limit/2, so it's a pure function of the count. With limit 20, 21..30
+    # images drop the oldest 10, 31..40 the oldest 20.
+    def self.dropped_count(total, limit)
+      return 0 if total <= limit
+
+      step = [limit / 2, 1].max
+      (((total - limit) + step - 1) / step) * step
     end
 
     # The Items for conversation[+index+] (none when it has no images).
@@ -120,7 +133,7 @@ module Samagotchi
     def skip_reason(index, position)
       return "no session images here" if @vision.nil?
       return CANT_SEE unless @vision.sendable?
-      return "only the newest #{@limit} images are sent" unless @sent.include?([index, position])
+      return "an older image (chi sends up to the newest #{@limit})" unless @sent.include?([index, position])
 
       nil
     end