samagotchi 0.27.0 → 0.29.0

data/lib/samagotchi/llm/openai_chat.rb

@@ -80,6 +80,17 @@ module Samagotchi
         false
       end
 
+      # true when +url+ is OpenAI's own API (api.openai.com).
+      def self.openai?(url)
+        URI(url.to_s).host.to_s.downcase == "api.openai.com"
+      rescue URI::Error
+        false
+      end
+
+      # Whether cache.key asks for the session id as `prompt_cache_key`
+      # (session; off, the default, or anything else sends none).
+      def self.cache_key? = Samagotchi::Config.get("cache.key").to_s.strip.downcase == "session"
+
       # Tool arguments as a Hash; "" is {}, invalid JSON stays a String.
       def self.parse_arguments(raw)
         return raw if raw.is_a?(Hash)
@@ -141,10 +152,10 @@ module Samagotchi
       # @return [ChatResponse]
       def chat(messages:, model:, tools: [], cancel_controller: nil, on_delta: nil, on_retry: nil, options: {},
                session_id: nil)
-        body = request_body(messages, tools, model, options)
+        body = request_body(messages, tools, model, options, session_id)
         request = post_request("#{@base_url}/chat/completions", body, session_id: session_id)
         log_fields = { model: model, purpose: @purpose, sampling: sampling_summary(body),
-                       cache: ("on" if PromptCache.marked?(body[:messages])) }
+                       cache: cache_summary(body[:messages]), cache_by: ("session" if body.key?(:prompt_cache_key)) }
         return chat_once(request, cancel_controller, log_fields) unless @stream
 
         assembly = Assembly.new
@@ -236,7 +247,7 @@ module Samagotchi
         [[open_timeout, timeout].min, timeout]
       end
 
-      def request_body(messages, tools, model, options)
+      def request_body(messages, tools, model, options, session_id)
         body = {
           model: model,
           messages: cache_breakpoints(Array(messages).map { |message| wire_message(message) }, model),
@@ -244,6 +255,7 @@ module Samagotchi
         }
         body[:stream_options] = { include_usage: true } if @stream
         body[:max_tokens] = @default_max_tokens if @default_max_tokens
+        body[:prompt_cache_key] = session_id.to_s if prompt_cache_key?(session_id)
         unless Array(tools).empty?
           body[:tools] = tools
           body[:tool_choice] = "auto"
@@ -264,10 +276,34 @@ module Samagotchi
         PromptCache.mark(messages, model: model)
       end
 
+      # The session id as `prompt_cache_key` (cache.key: session) goes only
+      # to the APIs that document it, OpenAI's and OpenRouter's (which also
+      # routes by it), for the session's own chat requests: a local server or
+      # another gateway may reject an unknown field.
+      def prompt_cache_key?(session_id)
+        return false if session_id.to_s.empty? || !@remote || @purpose != "chat"
+        return false unless self.class.openai?(@base_url) || self.class.openrouter?(@base_url)
+
+        self.class.cache_key?
+      rescue StandardError
+        false
+      end
+
+      # The log line's cache= : on for breakpoints with Anthropic's default
+      # TTL, 1h for cache.ttl 1h, nil for none.
+      def cache_summary(messages)
+        return nil unless PromptCache.marked?(messages)
+
+        hour = Array(messages).any? do |message|
+          Array(message[:content]).any? { |part| part.is_a?(Hash) && part.dig(:cache_control, :ttl) == "1h" }
+        end
+        hour ? "1h" : "on"
+      end
+
       # The body's fields beyond the conversation and the stream, for the
       # log line: "temperature=0.6 presence_penalty=1.5", nil for none.
       def sampling_summary(body)
-        SamplingSettings.log_text(body.except(:model, :messages, :stream, :stream_options, :tools, :tool_choice))
+        SamplingSettings.log_text(body.except(:model, :messages, :stream, :stream_options, :tools, :tool_choice, :prompt_cache_key))
       end
 
       # A String stays a String, an Array of parts an Array; both scrubbed

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/memory_bundle/installer.rb

@@ -303,6 +303,7 @@ module Samagotchi
         # Like the rules, the bundle's plugin replaces an earlier one.
         plugin_file_for_provenance = install_plugin(manifest, normalized_dir, provenance)
         warn_hooks_requires_chi(manifest, all_hooks_in_bundle)
+        warn_rules_requires_chi(manifest, incoming_rules)
 
         # Files the previous version shipped and this one doesn't.
         if @upgrade && existing_provenance && existing_provenance[:files]
@@ -559,6 +560,19 @@ module Samagotchi
         end
       end
 
+      # GuardrailWiring#bundle_rules doesn't read the rules of a bundle whose
+      # requires_chi this chi doesn't meet, and a session that never loaded
+      # them records a required load failure (the gate refuses guarded calls
+      # until chi is updated): say so at install, as the hooks warning does.
+      def warn_rules_requires_chi(manifest, rule_files)
+        return if manifest.nil? || rule_files.empty?
+
+        if (failure = Manifest.requires_chi_failure(manifest.requires_chi, Samagotchi::VERSION))
+          @warnings << "Bundle #{@name}: its guardrail rules won't load: #{failure}; until chi is updated " \
+                       "(chi update), guarded tool calls are refused"
+        end
+      end
+
       # Copy the manifest's plugin file into the bundle's plugin/ dir,
       # warning when its sha256 differs from the declared one or this chi
       # doesn't meet requires_chi (the Engine then won't load it).

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_commands.rb

@@ -5,6 +5,7 @@ require_relative "model_profile"
 require_relative "served_model"
 require_relative "turn_flow"
 require_relative "tools/execute"
+require_relative "tools/builtins"
 require_relative "commands/registry"
 
 module Samagotchi
@@ -207,12 +208,15 @@ module Samagotchi
     end
 
     # The output goes into the conversation for the next turn. Not saved
-    # here (as in the REPL, the next turn saves it).
+    # here (as in the REPL, the next turn saves it). No parent-session
+    # marker: the user runs this, not the model. A worker's `chi --model X`
+    # default is unset, though: it was that run's, not the default of a chi
+    # run here (Tools::Builtins.cli_model_unset).
     def shell(text)
       command = text.delete_prefix(SHELL_BANG_PREFIX).strip
       return reply("!: please provide a shell command after '!'", status: :error) if command.empty?
 
-      output = Samagotchi::Tools::Execute.call(command)
+      output = Samagotchi::Tools::Execute.call(command, env: Samagotchi::Tools::Builtins.cli_model_unset)
       @engine.append_messages([{ role: "user", content: "!(#{command})\n#{output}" }])
       # Rolling back past this would silently drop the command output.
       @turn_flow.note_conversation_changed

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/tool_activity.rb

@@ -12,6 +12,7 @@ require_relative "tools/edit"
 require_relative "tools/task_create"
 require_relative "tools/task_get"
 require_relative "tools/task_list"
+require_relative "tools/task_runtime"
 require_relative "tools/task_stop"
 require_relative "tools/task_wait"
 require_relative "tools/web_fetch"
@@ -62,11 +63,13 @@ module Samagotchi
     # command without its "cd … &&"): a file tool's path relative to +cwd+
     # when it is under it, a command's description (the model's few words),
     # else its first step and how many more (CommandSteps; its first line
-    # when it has no steps), a memory's name;
-    # nil for the other tools (a plugin's row keeps its preview, the
+    # when it has no steps), a memory's name, a task tool's task command
+    # (task_title); nil for the other tools (a plugin's row keeps its preview, the
     # params). +params+ stays the full key=value line (the TUI, the
     # guardrails).
     def tool_title(tool_name, call, cwd: nil)
+      return task_title(tool_name, call, cwd) if TASK_TOOLS.include?(tool_name)
+
       if [Tools::Execute::NAME, Tools::TaskCreate::NAME].include?(tool_name)
         title = command_description(tool_name, call) || steps_title(call[:content])
         return title if title
@@ -90,19 +93,42 @@ module Samagotchi
       end
     end
 
+    TASK_TOOLS = [Tools::TaskWait::NAME, Tools::TaskGet::NAME, Tools::TaskStop::NAME].freeze
+
+    # A task_wait / task_get / task_stop row's title: the task's command
+    # (its record under +cwd+, the process's directory when nil) as a
+    # command's title, and for a wait how long it waits ("npm test · up to
+    # 600s"). nil when there is no record: the row keeps its id.
+    def task_title(tool_name, call, cwd)
+      command = Tools::TaskRuntime.command_of(call[:content], root: cwd)
+      return nil unless command
+
+      suffix = ""
+      if tool_name == Tools::TaskWait::NAME
+        timeout = call[:timeout].to_s.strip
+        suffix = " · up to #{timeout.empty? ? Tools::TaskWait::TIMEOUT_DEFAULT : timeout.to_i}s"
+      end
+      room = TOOL_ACTIVITY_PREVIEW_LIMIT - suffix.length
+      text = steps_title(command, room) || command_title(command).gsub(/\s+/, " ")
+      return nil if text.empty?
+
+      text = "#{text[0, room - 1]}…" if text.length > room
+      "#{text}#{suffix}"
+    end
+
     # A leading "cd <dir> &&" / "cd <dir>;" goes: the model's habit, and it
     # eats the line.
     LEADING_CD = /\Acd\s+(?:"[^"]*"|'[^']*'|\S+)\s*(?:&&|;)\s*/
 
-    # "<first step> +N" (N the steps after it), cut to fit
-    # TOOL_ACTIVITY_PREVIEW_LIMIT; nil when the command has no steps.
-    def steps_title(command)
+    # "<first step> +N" (N the steps after it), cut to fit +limit+
+    # (TOOL_ACTIVITY_PREVIEW_LIMIT); nil when the command has no steps.
+    def steps_title(command, limit = TOOL_ACTIVITY_PREVIEW_LIMIT)
       steps = CommandSteps.parse(command)&.steps
       return nil unless steps
 
       first = steps.first.text.gsub(/\s+/, " ")
       more = steps.size > 1 ? " +#{steps.size - 1}" : ""
-      room = TOOL_ACTIVITY_PREVIEW_LIMIT - more.length
+      room = limit - more.length
       first = "#{first[0, room - 1]}…" if first.length > room
       "#{first}#{more}"
     end

data/lib/samagotchi/tools/builtins.rb

@@ -117,13 +117,16 @@ module Samagotchi
         peers = kctx.peers
         id = peers.respond_to?(:session_id) ? peers.session_id.to_s : ""
         model = peers.respond_to?(:model_ref) ? peers.model_ref.to_s : ""
-        vars = { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
-                 SESSION_MODEL_ENV => model.empty? ? nil : model }
-        if env[ModelProfile::MODEL_FROM_CLI_ENV]
-          vars[ModelProfile::MODEL_ENV] = nil
-          vars[ModelProfile::MODEL_FROM_CLI_ENV] = nil
-        end
-        vars
+        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
+          SESSION_MODEL_ENV => model.empty? ? nil : model }.merge(cli_model_unset(env))
+      end
+
+      # The unsets that keep a `chi --model X` worker's default from passing
+      # for the default of a chi run here (nothing when it wasn't the CLI's).
+      def cli_model_unset(env = ENV)
+        return {} unless env[ModelProfile::MODEL_FROM_CLI_ENV]
+
+        { ModelProfile::MODEL_ENV => nil, ModelProfile::MODEL_FROM_CLI_ENV => nil }
       end
 
       SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"

data/lib/samagotchi/tools/task_runtime.rb

@@ -129,6 +129,27 @@ module Samagotchi
         end.uniq
       end
 
+      # A task id as task_create makes them: no path parts.
+      TASK_ID = /\A[A-Za-z0-9_-]+\z/
+
+      # The command of the task +task_id+ under +root+ (a session's working
+      # directory) as its record has it, for a UI row's title; nil for no
+      # such task or an unreadable record. Reads the record only (no
+      # refresh), so it is cheap and never fails.
+      # @return [String, nil]
+      def command_of(task_id, root: Dir.pwd)
+        id = task_id.to_s.strip
+        return nil unless id.match?(TASK_ID)
+
+        path = File.join(root || Dir.pwd, TASKS_DIR, id, METADATA_FILENAME)
+        return nil unless File.file?(path)
+
+        command = JSON.parse(File.read(path))["command"]
+        command.is_a?(String) && !command.strip.empty? ? command : nil
+      rescue StandardError
+        nil
+      end
+
       def stopped_by_user?(record) = record["stop_reason"] == "stopped_by_user"
 
       def get_record(task_id)

data/lib/samagotchi/turn_note.rb

@@ -143,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
@@ -188,6 +188,16 @@ module Samagotchi
       list
     end
 
+    # A copy of +messages+ without the note at its tail when that note is a
+    # retry nudge (anything else stays: an earlier turn's note is what says
+    # why that turn ended).
+    def without_trailing_nudge(messages)
+      list = Array(messages).dup
+      index = trailing_index(list)
+      list.delete_at(index) if index && retry_nudge?(list[index])
+      list
+    end
+
     # The index of the note at the tail of +list+ (behind context notes at
     # most), or nil.
     def trailing_index(list)

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.27.0"
+  VERSION = "0.29.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

data/lib/samagotchi/web/public/app.js

@@ -39,7 +39,7 @@ import { ALL_SESSIONS_HASH, sessionHash, sessionIdFromHash } from "./route.js";
 import { allScopeHref, cardFolder, projectScopeHref, scopeDir } from "./scope.js";
 import { shouldFollowScroll, keepFollowing } from "./scroll.js";
 import { SHORT_WINDOW_QUERY, stripAutoHidden, stripColumns, stripShowParts } from "./strip.js";
-import { applySessionEvent, heldOrder, listedSessions, sortedByUpdated, waitingBadge, waitingFirst, waitingSearchText, withChildrenAfterParents } from "./sessions_list.js";
+import { applySessionEvent, heldOrder, listedSessions, sortedByUpdated, stoppedBadge, waitingBadge, waitingFirst, waitingSearchText, withChildrenAfterParents } from "./sessions_list.js";
 import { createNotifications } from "./notifications.js";
 import { restartConfirmText, versionNotice, workerBadge } from "./update_notice.js";
 import {
@@ -328,8 +328,12 @@ function cardHtml(s, { deletable = false } = {}) {
   const ctxHtml = ctx ? `<span class="ctx" title="${escapeHtml(tokensTipText(s.tokens))}">${escapeHtml(ctx)}</span>` : "";
   const waiting = waitingBadge(s);
   const waitingHtml = waiting ? `<span class="attn attn-${waiting.kind}" title="${escapeHtml(waiting.title)}">${escapeHtml(waiting.text)}</span>` : "";
+  // A turn a hook stopped wears its own badge, unless the session waits on
+  // the user (the waiting badge wins: the stop is behind the need).
+  const stopped = waiting ? null : stoppedBadge(s);
+  const stoppedHtml = stopped ? `<span class="stopped-badge" title="${escapeHtml(stopped.title)}">${escapeHtml(stopped.text)}</span>` : "";
   const dotWord = waiting ? waiting.title : s.status;
-  return `<div class="card${s.archived ? " archived" : ""}${waiting ? " waiting" : ""}" data-id="${s.id}" title="${escapeHtml(tip)}${memTitle ? ` · ${escapeHtml(memTitle)}` : ""}"><div class="preview">${preview}</div>${s.recap ? `<div class="recap" title="${escapeHtml(s.recap)}">${escapeHtml(s.recap)}</div>` : ""}<div class="meta"><span class="status dot ${escapeHtml(s.status)}${waiting ? " waiting" : ""}" title="${escapeHtml(dotWord)}" aria-label="${escapeHtml(dotWord)}"></span>${waitingHtml}${timeHtml}${ctxHtml}${folderHtml}${parentChipHtml(s)}${ownerBadgeHtml(s)}${archivedHtml}${s.used_memory_names && s.used_memory_names.length ? `<span title="${escapeHtml(s.used_memory_names.join(", "))}">mem ${s.used_memory_names.length}</span>` : ""}</div>${deletable ? `<button type="button" class="card-del" data-del="${escapeHtml(s.id)}" title="Delete session" aria-label="Delete session ${escapeHtml(s.short_id)}">\u2715</button>` : ""}</div>`;
+  return `<div class="card${s.archived ? " archived" : ""}${waiting ? " waiting" : ""}" data-id="${s.id}" title="${escapeHtml(tip)}${memTitle ? ` · ${escapeHtml(memTitle)}` : ""}"><div class="preview">${preview}</div>${s.recap ? `<div class="recap" title="${escapeHtml(s.recap)}">${escapeHtml(s.recap)}</div>` : ""}<div class="meta"><span class="status dot ${escapeHtml(s.status)}${waiting ? " waiting" : ""}" title="${escapeHtml(dotWord)}" aria-label="${escapeHtml(dotWord)}"></span>${waitingHtml}${stoppedHtml}${timeHtml}${ctxHtml}${folderHtml}${parentChipHtml(s)}${ownerBadgeHtml(s)}${archivedHtml}${s.used_memory_names && s.used_memory_names.length ? `<span title="${escapeHtml(s.used_memory_names.join(", "))}">mem ${s.used_memory_names.length}</span>` : ""}</div>${deletable ? `<button type="button" class="card-del" data-del="${escapeHtml(s.id)}" title="Delete session" aria-label="Delete session ${escapeHtml(s.short_id)}">\u2715</button>` : ""}</div>`;
 }
 
 // A delegated session's `↳ <parent>` chip; the parent's preview is the tooltip.
@@ -1483,6 +1487,10 @@ function clearTimingInterval() {
 }
 
 let liveTurnNumber = null;
+// The live line sits in the stage's status row, which already says the turn
+// runs ("running a tool"): it drops its own "running" there. It never moves
+// mid-turn (finishLiveTurnTiming rewrites it before any hand-off).
+let liveTurnTimingInStage = false;
 
 function startLiveTurnTiming(startedAt = new Date().toISOString(), turnId = null) {
   clearTimingInterval();
@@ -1495,7 +1503,9 @@ function startLiveTurnTiming(startedAt = new Date().toISOString(), turnId = null
   liveTurnTimingEl.className = "turn-timing live";
   // The stage's status row while it holds the turn: the line moves into the
   // history with it.
-  (turnDom.timingHost?.() || historyEl).appendChild(liveTurnTimingEl);
+  const stageHost = turnDom.timingHost?.() || null;
+  liveTurnTimingInStage = !!stageHost;
+  (stageHost || historyEl).appendChild(liveTurnTimingEl);
   updateLiveTiming();
   timingInterval = setInterval(updateLiveTiming, 1000);
 }
@@ -1509,7 +1519,7 @@ function appendToHistory(el) {
 function updateLiveTiming() {
   const duration = elapsedSince(current.timing.activeTurn?.started_at);
   if (liveTurnTimingEl && duration !== null) {
-    liveTurnTimingEl.textContent = turnTimingText(liveTurnNumber, duration, { running: true }) + (liveTurnNote ? ` · ${liveTurnNote}` : "");
+    liveTurnTimingEl.textContent = turnTimingText(liveTurnNumber, duration, { running: !liveTurnTimingInStage }) + (liveTurnNote ? ` · ${liveTurnNote}` : "");
   }
   updateInfoBar();
 }