samagotchi 0.16.0 → 0.18.0

data/lib/samagotchi/terminal_ui.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "io/console"
 require "reline"
 
+require_relative "iteration_limit"
 require_relative "model_profile"
 require_relative "turn_note"
 require_relative "config"
@@ -232,6 +233,10 @@ module Samagotchi
       @engine.session = session
       messages = messages_for(session)
 
+      # As typed at the prompt: a session command (/models, !ls) runs as
+      # the command, not as a turn.
+      return run_one_shot_command(session) if @prompt && @non_interactive && command_registry.command?(@prompt)
+
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
@@ -239,7 +244,7 @@ module Samagotchi
           session,
           @prompt,
           on_event: nil,
-          max_iterations: 1000,
+          max_iterations: IterationLimit.for(no_interrupt: true),
           cancel_controller: nil,
           images: ImageInput.extract(@prompt)
         )
@@ -281,6 +286,22 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # `chi -p "/models" --non-interactive`: the command's output; a refused
+    # one fails the run (bin/chi exits 1). The session is saved only when
+    # the command changed it.
+    # @return [Symbol, nil] :turn_failed when the command was refused
+    def run_one_shot_command(session)
+      line = @prompt.strip
+      result = begin
+        @commands.run(line)
+      rescue StandardError => e
+        SessionCommands::Result.new(status: :error, output: "#{line.split.first}: #{e.message}", changed: [])
+      end
+      @surface.commit(result.output) unless result.output.to_s.empty?
+      session.save unless Array(result.changed).empty?
+      :turn_failed if result.status == :error
+    end
+
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -465,7 +486,7 @@ module Samagotchi
     # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
     # Engine#run_turn, rendering via @renderer.
     # @param images [Array<Hash>] the prompt's `@path` images ({path:})
-    def run_engine_turn(session, prompt, continue: false, max_iterations: 100, images: [])
+    def run_engine_turn(session, prompt, continue: false, max_iterations: IterationLimit.for, images: [])
       cancellation_controller = CancellationController.new
       @active_cancel_controller = cancellation_controller
       @renderer.begin_turn
@@ -635,6 +656,9 @@ module Samagotchi
         return
       end
       return if show_local_command(input)
+      # A typo of a command (/modle) is not a prompt: say so, send nothing.
+      hint = command_registry.unknown_command_hint(input)
+      return @surface.commit(hint) if hint
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
@@ -921,6 +945,11 @@ module Samagotchi
       # A command, never steering text (/archive waits, back in the prompt).
       return command_during_turn(line) if local || command_registry.command?(line)
       return true if line.strip.empty?
+      # A typo of a command (/modle) is not steering text: say so, take it.
+      if (hint = command_registry.unknown_command_hint(line))
+        @surface.commit(hint)
+        return true
+      end
       # Steering merges text only: a line with images runs as the next turn.
       return image_line_waits if ImageInput.extract(line).any?
 
@@ -1184,6 +1213,10 @@ module Samagotchi
 
     # A ? read of its own, off a terminal (specs, pipes): $stdin.gets.
     def read_choice_line(question_prompt)
+      # Off a terminal the ? prompt can't be taken back: at the input's end
+      # it would stay bare above the summary. eof? waits as gets would.
+      return nil if !$stdin.tty? && $stdin.eof?
+
       @surface.set_slot(:editor, [question_prompt])
       line = $stdin.gets
       # A pipe doesn't echo: the line completes the ? prompt here, once,

data/lib/samagotchi/tool_declarations.rb

@@ -46,11 +46,11 @@ module Samagotchi
             },
             start_line: {
               type: "integer",
-              description: "Optional start line (1-based, inclusive). Must be provided with end_line."
+              description: "Optional start line (1-based, inclusive). Without end_line, reads to the end of the file."
             },
             end_line: {
               type: "integer",
-              description: "Optional end line (1-based, inclusive). Must be provided with start_line."
+              description: "Optional end line (1-based, inclusive). Without start_line, reads from line 1."
             }
           },
           required: ["path"]

data/lib/samagotchi/tools/builtins.rb

@@ -105,12 +105,20 @@ module Samagotchi
       # What execute and task_create export into the commands they run: a
       # chi started there answers as a parent agent
       # (Guardrails::ParentApprovals.parent_process?), even under a PTY
-      # wrapper. The session's id, "chi" without one.
+      # wrapper. The session's id, "chi" without one. And the model the
+      # session runs on (SAMAGOTCHI_SESSION_MODEL, read live, so right after
+      # /model), which chi self reports; unset when unknown, so a value
+      # inherited from an outer session never passes for this one.
       def parent_env(kctx)
-        id = kctx.peers.respond_to?(:session_id) ? kctx.peers.session_id.to_s : ""
-        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id }
+        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 : ""
+        { Guardrails::ParentApprovals::PARENT_SESSION_ENV => id.empty? ? "chi" : id,
+          SESSION_MODEL_ENV => model.empty? ? nil : model }
       end
 
+      SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+
       # Stop flips the turn's controller, seen through the Engine's PeerView
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)

data/lib/samagotchi/tools/delegate_relay.rb

@@ -55,6 +55,10 @@ module Samagotchi
         fields = Relay.card(child, question, relay_id: relay_id, more: more)
         answer = relay.open_question(fields, watch: watch(child_id, qid, state_dir))
         settle(answer, fields, client: client, desk: desk, relay_id: relay_id, qid: qid)
+      ensure
+        # A relay that failed before it settled closes, so the desk (which
+        # prunes only settled ones) keeps none open; a settled one stays.
+        desk&.close(relay_id) if relay_id
       end
 
       # Closes the card when the child's question is no longer pending (it

data/lib/samagotchi/tools/delegate_wait.rb

@@ -139,7 +139,7 @@ module Samagotchi
         when :canceled
           canceled_result(child_id)
         when :no_reply
-          result(child_id, status, "#{no_reply_text(wait)}; its session shows what happened")
+          result(child_id, status, "#{no_reply_text(wait, child_id)}; its session shows what happened")
         when :worker_gone
           result(child_id, status,
                  "the child's worker is gone (it stopped or crashed); delegate with session: #{child_id} starts it again with a message")
@@ -168,8 +168,8 @@ module Samagotchi
       end
 
       # ParentReport's line for a turn that left no reply, about the child.
-      def no_reply_text(wait)
-        ParentReport.no_reply_line(wait).sub(/\Athe turn/, "the child's turn")
+      def no_reply_text(wait, child_id)
+        ParentReport.no_reply_line(wait, child_id).sub(/\Athe turn/, "the child's turn")
       end
 
       def result(child_id, status, text)
@@ -184,9 +184,18 @@ module Samagotchi
 
       # The whole question, as `chi send --wait` prints it (ParentReport):
       # its text, options and the commands that answer it.
+      # A step-limit question (kind continue) is the parent model's to
+      # decide (it isn't relayed: Continue grants no permission): continue
+      # it with chi answer through execute, send a follow-up instead, or
+      # report back.
       def waiting_text(child_id, pending)
-        "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}" \
-          "delegate_result #{child_id} waits again once it is answered."
+        text = "Child #{child_id} is #{ParentReport.question_text(pending, session_id: child_id)}"
+        if ParentReport.continue?(pending)
+          text += "The child ran out of steps before it answered. Decide: continue it (run the chi answer command " \
+                  "above with execute) if it is getting somewhere; send it a narrower follow-up with delegate " \
+                  "session: #{child_id} (that drops the question); or stop it and report back to your user.\n"
+        end
+        "#{text}delegate_result #{child_id} waits again once it is answered."
       end
 
       def cut(text)

data/lib/samagotchi/tools/edit.rb

@@ -62,6 +62,9 @@ module Samagotchi
         "Error: #{e.message}"
       end
 
+      START_LINE_REQUIRED = "Error: end_line alone isn't enough for a range edit; " \
+                            "pass start_line too (1-based, the first line to replace)"
+
       def self.apply_range_mode(new_text, path:, start_line:, end_line:, read:)
         return "Error: file not found: #{path}" unless File.exist?(path)
         return NEW_TEXT_REQUIRED if new_text.nil?
@@ -70,7 +73,9 @@ module Samagotchi
 
         start_num = parse_positive_line_number(start_line, "start_line")
         return start_num if start_num.is_a?(String)
-        return "Error: start_line must be provided for range edits" if start_num.nil?
+        # Not defaulted to 1 like read: a range edit replaces the span, so a
+        # guessed start would silently overwrite the top of the file.
+        return START_LINE_REQUIRED if start_num.nil?
 
         source = read.(path)
         lines = source.lines

data/lib/samagotchi/tools/execute.rb

@@ -15,11 +15,12 @@ module Samagotchi
     #   <tool name="execute">ruby path/to/script.rb</tool>
     class Execute
       NAME        = "execute"
-      TIMEOUT_SEC = 30
+      TIMEOUT_SEC = 120
       STOP_GRACE_SEC = 1.0
       STOP_POLL_INTERVAL_SEC = 0.05
       WAIT_SLICE_SEC = 0.2
       NOT_RUN_ON_STOP = "Error: not run, the user stopped the turn"
+      TIMEOUT_HINT = "(killed at the limit; for a long command use task_create, then task_wait)"
 
       def self.name        = NAME
 
@@ -51,9 +52,9 @@ module Samagotchi
         parts << (silent ? "exit: #{status.exitstatus} (no output)" : "exit: #{status.exitstatus}")
         parts.join("\n")
       rescue CommandTimedOut => e
-        # Keep the "Error:" first line (callers classify on it) and return
-        # whatever the command printed before it was killed.
-        stopped_result("Error: command timed out after #{timeout_sec}s", e)
+        # Keep the "Error:" first line (callers classify on it), say how to run
+        # a long command, and return whatever it printed before it was killed.
+        stopped_result("Error: command timed out after #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
         stopped_result("Error: command stopped by the user after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
       rescue => e

data/lib/samagotchi/tools/peers.rb

@@ -7,10 +7,11 @@ module Samagotchi
     # folder, where sessions live, and whether the running turn was
     # canceled (a waiting tool returns on it), and the question flow a
     # delegate's approval is relayed through (relay: nil when this session
-    # can't host one). Engine hands KernelLoop one that follows its current
+    # can't host one), and the model the session runs on (model_ref: the
+    # resolved ref, live after /model). Engine hands KernelLoop one that follows its current
     # session (Engine::PeerView); this plain one is for specs and a kernel
     # without an Engine.
-    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, keyword_init: true) do
+    Peers = Struct.new(:session_id, :cwd, :state_dir, :cancelled, :relay, :model_ref, keyword_init: true) do
       # @return [Boolean] the turn was canceled (:cancelled is a proc or a value)
       def cancelled?
         cancelled.respond_to?(:call) ? !!cancelled.call : !!cancelled

data/lib/samagotchi/tools/read.rb

@@ -124,7 +124,8 @@ module Samagotchi
 
         start_num = parse_positive_line_number(start_line, "start_line")
         return start_num if start_num.is_a?(String)
-        return "Error: start_line must be provided for range reads" if start_num.nil?
+        # end_line alone reads from the top of the file.
+        start_num ||= 1
 
         end_provided = !blank?(end_line)
         end_num = end_provided ? parse_positive_line_number(end_line, "end_line") : nil

data/lib/samagotchi/tools/task_runtime.rb

@@ -20,7 +20,7 @@ module Samagotchi
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       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].freeze
+      MARKER_ENV_KEYS = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
 
       module_function
 

data/lib/samagotchi/turn_flow.rb

@@ -108,12 +108,13 @@ module Samagotchi
       @checkpoint = nil
     end
 
-    # Answer the offer with no: the interrupted turn is discarded, and a
-    # reason (with a summary of that turn) is left for the model to read.
+    # Answer the offer with no (Stop): the interrupted turn stays, as
+    # after a Ctrl-C or a new prompt (!rollback still erases it), and the
+    # model reads that it wasn't continued: a note, or the user's reason
+    # (with a summary of that turn).
     def abort_continue!(reason: nil)
-      restore(@checkpoint) if @checkpoint
-      @checkpoint = nil
-      @engine.append_messages([{ role: "user", content: reason_message(reason) }]) if reason
+      message = reason ? { role: "user", content: reason_message(reason) } : TurnNote.not_continued
+      @engine.append_messages([message])
       @offer = nil
     end
 
@@ -212,9 +213,9 @@ module Samagotchi
 
     def reason_message(reason)
       context = @offer && @offer[:context]
-      lines = ["I chose not to continue the interrupted turn because: #{reason}"]
+      lines = ["I chose not to continue the turn that ran out of steps because: #{reason}"]
       lines << ""
-      lines << "Interrupted turn summary:"
+      lines << "Its work so far stays. Interrupted turn summary:"
       original_prompt = context && context[:original_prompt]
       lines << "- original_prompt: #{original_prompt.to_s.empty? ? "(unavailable)" : original_prompt}"
 

data/lib/samagotchi/turn_note.rb

@@ -131,6 +131,13 @@ module Samagotchi
       (entry[:kind] || entry["kind"]).to_s == KIND
     end
 
+    # The step-limit offer answered Stop (no reason): the partial turn
+    # stays, and the model reads that it wasn't continued.
+    def not_continued
+      message("the previous turn ran out of steps before it answered, and the user chose not to continue it. " \
+              "Its work so far (tool calls, file changes) stays; wait for the user's next message.")
+    end
+
     def message(text)
       { role: "system", content: "#{OPEN}#{text}#{CLOSE}", kind: KIND }
     end

data/lib/samagotchi/version.rb

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