samagotchi 0.58.0 → 0.59.0

data/lib/samagotchi/steer_cut.rb

@@ -30,19 +30,23 @@ module Samagotchi
     end
 
     # +clock+: monotonic seconds; +controller+: the running turn's cancel
-    # controller (nil between turns), read only when a cut is due.
-    def initialize(clock:, controller:)
+    # controller (nil between turns), read only when a cut is due;
+    # +cut_after+: seconds a thinking-only generation may stream before a
+    # cut, called on every check (the Engine passes the model's own
+    # SteerCutAfter; the global steer.cut_after here).
+    def initialize(clock:, controller:, cut_after: -> { self.class.cut_after })
       # What the running generation streams: whether a steer may cut it.
       @phase = GenerationPhase.new(clock: clock)
       # A message that may cut it but came too early: it cuts later.
       @waiting = WaitingSteer.new
+      @cut_after = cut_after
       @controller = controller
     end
 
     # A message for the running turn from +source+ (Steer.source_for_client:
     # nil for the user, "chi_send", "parent_agent") cuts the streaming
-    # generation when it has streamed only thinking for steer.cut_after
-    # seconds (GenerationPhase): the loops' cut path (CutPolicy) then starts
+    # generation when it has streamed only thinking for cut_after seconds
+    # (GenerationPhase): the loops' cut path (CutPolicy) then starts
     # the step again with the message, no nudge, no retry spent. Too early,
     # the message waits (WaitingSteer) and cuts once the thinking passes it
     # (#recheck, on each thinking chunk), unless a boundary hands it to the
@@ -52,13 +56,13 @@ module Samagotchi
     # before queueing it. Outside any lock; a cut that lands just after the
     # generation ended is harmless (the loop re-asks).
     # @return [Symbol] :now (a generation was cut now), :waits (the message
-    #   waits for the thinking to pass steer.cut_after), or :off (cutting
+    #   waits for the thinking to pass cut_after), or :off (cutting
     #   off for this source: a plugin, no turn, cut_after 0, a generation
     #   that isn't thinking-only, or a drain already took the message)
     def cut_for_steer(source, epoch: nil)
       return :off unless Steer.cuts?(source)
 
-      after = self.class.cut_after
+      after = @cut_after.call.to_i
       return :off unless after.positive?
 
       ctrl = @controller.call
@@ -107,11 +111,11 @@ module Samagotchi
     private
 
     # A thinking chunk streamed: a waiting message cuts once the thinking
-    # passes steer.cut_after.
+    # passes cut_after.
     def recheck
       return unless @waiting.waiting?
 
-      after = self.class.cut_after
+      after = @cut_after.call.to_i
       return unless after.positive? && @phase.cuttable?(after)
 
       source = @waiting.take

data/lib/samagotchi/steer_cut_after.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Samagotchi
+  # How long a message sent as a cut waits for the generation it came during:
+  # the seconds a generation must have streamed only thinking before a cut may
+  # land (SteerCut), one per model, host or run, like Thinking for the level.
+  #
+  # Order (#resolve): the env (SAMAGOTCHI_STEER_CUT_AFTER), then
+  # models.<key>.steer_cut_after, hosts.<name>.steer_cut_after,
+  # steer.cut_after in config.yml, then 20. 0 = never cut (a slow local
+  # thinker is left alone); it is a value, not an unset.
+  module SteerCutAfter
+    KEY = "steer_cut_after"
+    ENV_KEY = "SAMAGOTCHI_STEER_CUT_AFTER"
+    DEFAULT = 20
+
+    module_function
+
+    # A `steer_cut_after:` setting (hosts: entry or models: entry): whole
+    # seconds ≥ 0 (0 = never), nil when unset; anything else warns once,
+    # naming +where+, and counts as unset.
+    # @return [Integer, nil]
+    def seconds(value, where)
+      return nil if value.nil?
+
+      text = value.to_s.strip
+      return text.to_i if text.match?(/\A\d+\z/)
+
+      ConfigFile.warn_once "Warning: #{where}: steer_cut_after must be whole seconds (0 = never); ignored"
+      nil
+    end
+
+    # The seconds for +target+ and where they came from
+    # ("SAMAGOTCHI_STEER_CUT_AFTER", "models: qwen", "hosts.splash",
+    # "steer.cut_after"; nil for the default).
+    # @param target [HostRegistry::ModelTarget]
+    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
+    # @param models [Hash{String => ModelSettings}, nil] ConfigFile.model_settings (specs)
+    # @return [Array(Integer, String|nil)]
+    def resolve(target, names:, models: nil)
+      value, origin = Config.get_with_origin("steer.cut_after")
+      return [value.to_i, ENV_KEY] if origin == :env
+
+      models ||= begin
+        ConfigFile.model_settings
+      rescue StandardError
+        {}
+      end
+      setting = ConfigFile.model_setting(names, :steer_cut_after, models: models)
+      return [setting.value, "models: #{setting.key}"] if setting
+
+      host = target.entry.steer_cut_after
+      return [host, "hosts.#{target.entry.name}"] unless host.nil?
+
+      return [value.to_i, "steer.cut_after"] if origin == :file
+
+      [DEFAULT, nil]
+    end
+
+    # "after 60 s (models: qwen)"; 0 or less is "never (hosts.splash)".
+    # No source: just the seconds.
+    def label(seconds, source)
+      text = seconds.to_i <= 0 ? "never" : "after #{seconds} s"
+      source ? "#{text} (#{source})" : text
+    end
+  end
+end

data/lib/samagotchi/system_prompt.rb

@@ -16,7 +16,7 @@ module Samagotchi
   # The system prompt an Engine gives its model: the base prompt (tool
   # declarations and call syntax for the raw-prompt loop, none for the chat
   # loop, the shared guidance) and around it the thinking token, rg
-  # guidance, the identity memory, the model notes, the preloaded memories, AGENT.md, the
+  # guidance, the identity memory, the model notes, the preloaded memories, AGENTS.md, the
   # memory indexes and, last, the model, where the session runs and the
   # session (#system_prompt_with_index has the order and why).
   #
@@ -24,7 +24,7 @@ module Samagotchi
   # tools a plugin replaces, the attached session, the thinking level) is
   # read at build time through the lookups; the memory lists are fixed.
   class SystemPrompt
-    AGENT_DESCRIPTION_FILE = "AGENT.md"
+    AGENT_DESCRIPTION_FILE = "AGENTS.md"
 
     # The model a session runs on, as the prompt names it: the resolved
     # ref, its host ("name, host:port" or url), the memory overlay key, and
@@ -282,7 +282,7 @@ module Samagotchi
     # Ordered for the servers' prompt caches (they reuse only an exact token
     # prefix): what every session shares first, what changes least before
     # what changes more, and the per-session lines last. The global parts
-    # (identity, preloads) come before the project's AGENT.md, the memory
+    # (identity, preloads) come before the project's AGENTS.md, the memory
     # indexes (a memory write changes them) after both; the model, the
     # location and the session close the prompt (Gemma's tool declarations
     # still follow them).
@@ -464,7 +464,7 @@ module Samagotchi
 
     # ── Project / rg helpers ───────────────────────────────────────────────────
 
-    # AGENT.md in the cwd, else at the top of its git work tree.
+    # AGENTS.md in the cwd, else at the top of its git work tree.
     def project_specific_description
       return nil if skip_agent_description?
 
@@ -566,7 +566,7 @@ module Samagotchi
     end
 
     def skip_agent_description?
-      Config.get("skip_agent_md") == true
+      Config.get("skip_agents_md") == true
     end
 
     def rg_available?

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -712,7 +712,7 @@ module Samagotchi
 
         return NEXT_STEP_NOTE unless delivery == Delivery::CUT
 
-        steer_cut_note(ack["cut"].to_s.to_sym)
+        steer_cut_note(ack["cut"].to_s.to_sym, ack["cut_after"])
       end
 
       def send_prompt(text, delivery: nil)

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -99,8 +99,9 @@ module Samagotchi
       # What a line submitted at the open prompt says became of it: a plain
       # line goes in at the running turn's next step boundary (nothing cuts
       # unless the message asked for it), /cut's cutting now or once the
-      # thinking passes steer.cut_after, and /queue's waiting for the end.
-      # Both TUIs and chi send --cut print the same words
+      # thinking passes the model's cut wait (the run's cut_after; the global
+      # steer.cut_after when the worker didn't say), and /queue's waiting for
+      # the end. Both TUIs and chi send --cut print the same words
       # (SteerCut#cut_for_steer's answer).
       NEXT_STEP_NOTE = "(goes in at the next step)"
       CUT_NOW_NOTE = "(cut in now)"
@@ -116,17 +117,20 @@ module Samagotchi
       STEER_CHOICE = /\A(#{CUT_COMMAND}|#{QUEUE_COMMAND})(?:\s+(.*))?\z/m
 
       # @param outcome [Symbol] SteerCut#cut_for_steer's answer: :now, :waits or :off
+      # @param after [Integer, nil] the run's cut wait (the model's own
+      #   SteerCutAfter): the seconds a :waits waits for; the global
+      #   steer.cut_after when not given.
       # @return [String] the dim line to show for a /cut
-      def self.steer_cut_note(outcome)
+      def self.steer_cut_note(outcome, after = nil)
         case outcome
         when :now then CUT_NOW_NOTE
-        when :waits then format(CUT_WAITS_NOTE, SteerCut.cut_after)
+        when :waits then format(CUT_WAITS_NOTE, after || SteerCut.cut_after)
         else CUT_OFF_NOTE
         end
       end
 
       # The same words, for a UI that includes the module.
-      def steer_cut_note(outcome) = Formatting.steer_cut_note(outcome)
+      def steer_cut_note(outcome, after = nil) = Formatting.steer_cut_note(outcome, after)
 
       # The choice a mid-turn line carries, as [:cut, "TEXT"] or
       # [:queue, "TEXT"]; nil for any other line. The text is "" when the

data/lib/samagotchi/terminal_ui.rb

@@ -1199,7 +1199,7 @@ module Samagotchi
       @pending_input_queue.push(text)
       # With no session running the cut is :off; the text still waits for
       # the running turn's next step.
-      @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch)))
+      @surface.commit(steer_cut_note(@engine.cut_for_steer(nil, epoch: epoch), @engine.steer_cut_after))
       true
     end
 

data/lib/samagotchi/tool_activity.rb

@@ -46,7 +46,11 @@ module Samagotchi
         status: tool_activity_status(result, tool_name, command: call.is_a?(Hash) ? call[:content] : nil)
       }
       # A grep that found nothing: ok, and the web row says "no match".
-      event[:no_match] = true if event[:status] == "ok" && tool_name == Tools::Execute::NAME && execute_failed?(result.to_s)
+      # Not a hand-over: an "exit: 1" in its output tail is the command's.
+      if event[:status] == "ok" && tool_name == Tools::Execute::NAME && !handed_over?(tool_name, result) &&
+         execute_failed?(result.to_s)
+        event[:no_match] = true
+      end
       title = tool_title(tool_name, call, cwd: cwd)
       event[:title] = title if title
       # The name the model used when an alias ran a built-in (called_as: "bash"
@@ -214,6 +218,8 @@ module Samagotchi
       return "stopped" if text == Tools::Execute::NOT_RUN_ON_STOP
       return "stopped" if tool_name == Tools::Execute::NAME && text.start_with?(Tools::Execute::STOPPED_BY_USER)
       return "error" if text.start_with?("Error:")
+      # Still running, as a task: its output tail may hold any "exit: N".
+      return "ok" if handed_over?(tool_name, text)
       if tool_name == Tools::Execute::NAME && execute_failed?(text)
         return no_match?(text, command) ? "ok" : "error"
       end
@@ -222,6 +228,17 @@ module Samagotchi
       "ok"
     end
 
+    # An execute still running at its limit, handed over as a task
+    # (Tools::Execute::HANDED_OVER).
+    def handed_over?(tool_name, text)
+      return false unless tool_name == Tools::Execute::NAME && text.to_s.start_with?(Tools::Execute::HANDED_OVER)
+
+      # The first line only, scrubbed: a regexp raises on bytes that aren't UTF-8.
+      text.to_s.each_line.first.to_s.scrub.match?(HANDED_OVER_START)
+    end
+
+    HANDED_OVER_START = /\A#{Regexp.escape(Tools::Execute::HANDED_OVER)} \d+s limit:/
+
     def execute_failed?(text)
       code = execute_exit_code(text)
       !code.nil? && code != "0"

data/lib/samagotchi/tool_declarations.rb

@@ -20,7 +20,7 @@ module Samagotchi
     TOOL_SCHEMAS = [
       {
         name: "execute",
-        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. Don't background with &; use task_create.",
+        description: "Run any shell command in a working directory (defaults to the project root) and see stdout, stderr, and exit code. Large output may be truncated to a head+tail preview with metadata. A command still running at the time limit keeps running as a background task (by default): the result gives its task_id, and task_wait waits for it. Don't background with &; use task_create.",
         parameters: {
           type: "object",
           properties: {