samagotchi 0.57.0 → 0.59.0

data/lib/samagotchi/redacted_inspect.rb

@@ -2,21 +2,28 @@
 
 module Samagotchi
   # A single redacted #inspect for the classes that hold the process
-  # environment (@env, every API key) or the web token (@token): instead of
-  # dumping every instance variable (which would print the keys), it shows the
-  # rest with each value's own inspect and prints the others as [redacted]. A
-  # failing spec, a debugger or an error message that inspects one of them used
-  # to leak every key.
+  # environment (@env, every API key) or the web token (@token, or a :token
+  # key inside a Hash ivar, as Web::App's @lan): instead of dumping every
+  # instance variable (which would print the keys), it shows the rest with
+  # each value's own inspect and prints the others as [redacted]. A failing
+  # spec, a debugger or an error message that inspects one of them used to
+  # leak every key.
   module RedactedInspect
     # The instance variables never printed.
     REDACTED = %i[@env @token].freeze
+    # The keys of a Hash ivar whose values are never printed; the rest of the
+    # Hash is, so Web::App's @lan still shows its :ip.
+    REDACTED_KEYS = %i[token].freeze
+
+    # Stands in for a redacted Hash value: inspects as [redacted], unquoted.
+    HIDDEN = Object.new.tap { |hidden| hidden.define_singleton_method(:inspect) { "[redacted]" } }.freeze
 
     def inspect
       body = instance_variables.map do |ivar|
         if REDACTED.include?(ivar)
           "#{ivar}=[redacted]"
         else
-          "#{ivar}=#{instance_variable_get(ivar).inspect}"
+          "#{ivar}=#{redacted_value(instance_variable_get(ivar)).inspect}"
         end
       end.join(", ")
       "#<#{self.class.name} #{body}>"
@@ -24,5 +31,13 @@ module Samagotchi
 
     # pp otherwise ignores inspect.
     def pretty_print(printer) = printer.text(inspect)
+
+    private
+
+    def redacted_value(value)
+      return value unless value.is_a?(Hash) && REDACTED_KEYS.any? { |key| value.key?(key) }
+
+      value.to_h { |key, item| [key, REDACTED_KEYS.include?(key) ? HIDDEN : item] }
+    end
   end
 end

data/lib/samagotchi/send_command.rb

@@ -586,7 +586,7 @@ module Samagotchi
       outcome = Delivery.cut?(delivery) ? ack["cut"].to_s : ""
       return " (goes in at the running turn's next step)" unless CUT_OUTCOMES.include?(outcome)
 
-      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym)}"
+      " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, ack["cut_after"])}"
     end
 
     # More keys for --format json, with --cut only (the line is unchanged

data/lib/samagotchi/session_commands.rb

@@ -188,12 +188,12 @@ module Samagotchi
     # @return [String, nil]
     def self.builtin_name(line) = builtin_registry.lookup(line)&.name
 
-    # @return [String] the model /model clear goes back to
+    # @return [String, nil] the model /model clear goes back to; nil when none
     attr_reader :default_model
 
-    # @param default_model [String] the config default, which /model clear
+    # @param default_model [String, nil] the config default, which /model clear
     #   restores and /model names (the Engine may have started elsewhere, e.g.
-    #   on a resumed session's model)
+    #   on a resumed session's model); nil when the config names no default
     # @param save [#call] saves a session (a worker passes its state dir)
     # @param registry [Commands::Registry] the commands #run looks lines up in
     def initialize(engine:, turn_flow:, default_model:, save: ->(session) { session.save },
@@ -328,7 +328,9 @@ module Samagotchi
       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, env: Samagotchi::Tools::Builtins.cli_model_unset)
+      # Killed at the limit, never handed over: the output goes in a user
+      # message, which no one reads a task id from (created_ids_in).
+      output = Samagotchi::Tools::Execute.call(command, env: Samagotchi::Tools::Builtins.cli_model_unset, on_timeout: :kill)
       @engine.append_messages([{ role: "user", content: "!(#{command})\n#{output}" }])
       # Rolling back past this would silently drop the command output.
       @turn_flow.note_conversation_changed
@@ -484,9 +486,9 @@ module Samagotchi
     def model_command(input)
       suffix = input.delete_prefix(MODEL_COMMAND).strip
       if suffix.empty?
-        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if model_name == @engine.model_ref_for(@default_model)
+        return ["runtime model: #{model_name}#{model_note}#{served_note}#{sampling_note}#{steer_cut_after_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false] if @default_model.nil? || model_name == @engine.model_ref_for(@default_model)
 
-        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
+        return ["runtime model: #{model_name}#{model_note("default: #{@default_model}")}#{served_note}#{sampling_note}#{steer_cut_after_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", false]
       end
 
       # Parse flags: --default and --alias <name> / --alias=<name> (tolerant order)
@@ -554,6 +556,7 @@ module Samagotchi
 
         if ConfigFile::RESERVED_MODEL_ALIASES.include?(arg.downcase)
           return ["--default cannot be combined with clear/default/none/off", false] if persist_default
+          raise ModelProfile::MissingModel, "no default model is configured (set default.model in config.yml, or /model <name> --default)" if @default_model.nil?
 
           switch_model(@default_model)
           return ["runtime model reset to #{model_name}#{model_note}#{thinking_note}#{reasoning_history_note}#{notes_note}", true]
@@ -605,6 +608,16 @@ module Samagotchi
       ""
     end
 
+    # "; steer cut: after 60 s (models: qwen)", or "; steer cut: never
+    # (hosts.splash)" for 0 or less, when the model has one configured;
+    # "" for the default.
+    def steer_cut_after_note
+      summary = @engine.steer_cut_summary
+      summary ? "; steer cut: #{summary}" : ""
+    rescue StandardError
+      ""
+    end
+
     # "; notes: model_notes_deepseek (system, 612 chars)": the model notes
     # the session's prompt carries (after a switch, the ones the new
     # model's prompt loads); "" without any.

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)
@@ -1456,9 +1456,7 @@ module Samagotchi
 
       # The config's default model, as the worker's /model names it.
       def default_model_name
-        @default_model_name ||= ModelProfile.required_model_name(nil)
-      rescue StandardError
-        nil
+        @default_model_name ||= ModelProfile.default_model_name
       end
 
       def reminder_origin?(origin) = origin[:client_id].to_s.start_with?(ClientId::SYSTEM_PREFIX)

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

@@ -98,7 +98,7 @@ module Samagotchi
       @thinking_word  = thinking
       @prompt         = prompt
       @llm_context_words = llm_context
-      @default_model_name = ModelProfile.required_model_name(nil)
+      @default_model_name = ModelProfile.default_model_name
       # As typed: the Engine applies an alias where it resolves the model.
       flag_model_name = model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(model_name)
       @effective_model_name = flag_model_name || @default_model_name
@@ -127,6 +127,12 @@ module Samagotchi
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
       end
+      # No --model, no session model and no default: nothing to run.
+      raise ModelProfile::MissingModel, ModelProfile.missing_model_message if @effective_model_name.to_s.strip.empty?
+
+      # With no config default the Engine starts on the model it runs.
+      no_default = @default_model_name.nil?
+
       # The model it starts on names a configured host (a bad default.model
       # doesn't matter when --model or the session picks another).
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
@@ -166,8 +172,10 @@ module Samagotchi
         session_id: session_id,
         no_interrupt: no_interrupt,
         # nil: the config default, unchecked here (the model the REPL starts
-        # on is checked above, and --model may make the default moot).
-        model_name: nil,
+        # on is checked above, and --model may make the default moot). With
+        # no default, the model it runs (the switch below is then skipped).
+        model_name: no_default ? @effective_model_name : nil,
+        model_typed: no_default ? @resumed_model_typed : nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         recap: scratch ? nil : recap_config,
@@ -199,8 +207,9 @@ module Samagotchi
       @commands = SessionCommands.new(engine: @engine, turn_flow: @turn_flow, default_model: @default_model_name,
                                       registry: @engine.command_registry)
       # Runtime --model flag or resumed session: switch the Engine (client,
-      # kernel profile) without persisting the default.
-      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if @effective_model_name != @default_model_name
+      # kernel profile) without persisting the default. Skipped when there's
+      # no config default (the Engine was built on the session model).
+      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if !no_default && @effective_model_name != @default_model_name
       # Render an idle session-recap via the cursor-safe background writer; the
       # detector itself is Engine-owned (see Engine#recap) and opt-in.
       @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })
@@ -1190,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: {