samagotchi 0.17.0 → 0.18.1

data/lib/samagotchi/terminal_ui/question_prompt.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "question_slot"
+require_relative "../turn_flow"
 
 module Samagotchi
   class TerminalUI
@@ -12,7 +13,10 @@ module Samagotchi
     # Bridge). An approval (kind "approval") takes only a number, an exact
     # label, y (the first option, Allow once) or n (the last, Deny), plus
     # an optional "; reason"; a substring would pick the wrong one ("y" is
-    # in "Deny").
+    # in "Deny"). The step-limit question (kind "continue") reads the
+    # continue words (TurnFlow.continue_decision): Enter, yes, y or
+    # /continue continue; no stops; "no, why" stops with the reason; 1 and
+    # 2 pick the options.
     class QuestionPrompt
       DIFF_CODES = { "+" => 32, "-" => 31, "@" => 2, "\\" => 2 }.freeze
 
@@ -51,11 +55,13 @@ module Samagotchi
         @multi = !!field.(:multi_select)
         @free = !!field.(:allow_freeform)
         @approval = field.(:kind).to_s == "approval"
+        @continue = field.(:kind).to_s == "continue"
       end
 
       def multi? = @multi
       def free? = @free
       def approval? = @approval
+      def continue? = @continue
 
       # The relay mark (QuestionDesk#annotate's relayed_to: a Hash, or the
       # short id), or nil when cleared.
@@ -77,6 +83,7 @@ module Samagotchi
       # What a question closed with no answer here says: a relayed approval
       # names where it went; else "(question cancelled)".
       def closed_text(reason)
+        return CONTINUE_CLOSED.fetch(reason.to_s, "(question cancelled)") if continue?
         return "(question cancelled)" unless @delegate
 
         case reason.to_s
@@ -98,6 +105,10 @@ module Samagotchi
                          hint: slot_hint, question_code: approval? ? 33 : 94, paint: paint, note: note)
       end
 
+      # Why a step-limit question closed unanswered here.
+      CONTINUE_CLOSED = { "dropped" => "(dropped: a new prompt came)", "answered" => "(answered with /continue)",
+                          "superseded" => "(set aside for another question)", "replaced" => "(asked again)" }.freeze
+
       # The most diff lines #preview_lines prints; the web shows them all.
       PREVIEW_LINES = 40
 
@@ -138,7 +149,7 @@ module Samagotchi
       # @return [String] "Banana", "Apple, Cherry; ripe ones", "Deny: use a PR"
       def answer_text(answer)
         picked = answer.selected.to_a
-        if approval?
+        if approval? || continue?
           choice = picked.first || options.last
           return answer.freeform ? "#{choice}: #{answer.freeform}" : choice
         end
@@ -150,6 +161,7 @@ module Samagotchi
       # @return [Answer]
       def parse(raw)
         return parse_approval(raw) if approval?
+        return parse_continue(raw) if continue?
 
         raw = raw.to_s.strip
         # "1,3; my text": the first ';' separates the selection from freeform text.
@@ -178,6 +190,9 @@ module Samagotchi
       def mark = approval? ? "! " : "? "
 
       def slot_hint
+        if continue?
+          return "Enter or yes = #{options.first}; no = #{options.last}; no, <reason> = #{options.last} and tell the model why"
+        end
         if approval?
           return "1-#{options.size}, y = #{options.first}, n = #{options.last}; add '; reason' to tell the model why; " \
                  "Enter alone denies"
@@ -189,6 +204,23 @@ module Samagotchi
         hint.join("; ")
       end
 
+      # The continue words, or an option's number. Empty is Continue (Enter
+      # alone, as at the REPL's continue prompt).
+      def parse_continue(raw)
+        text = raw.to_s.strip
+        if text.match?(/\A\d+\z/)
+          idx = text.to_i - 1
+          return Answer.new(selected: [options[idx]]) if idx.between?(0, options.size - 1)
+        end
+        decision, reason = TurnFlow.continue_decision(text)
+        case decision
+        when :resume then Answer.new(selected: [options.first])
+        when :abort then Answer.new(selected: [options.last])
+        when :abort_with_reason then Answer.new(selected: [options.last], freeform: reason)
+        else Answer.new(error: "Answer yes (Enter alone too), no, or no, <reason>.")
+        end
+      end
+
       def parse_approval(raw)
         sel_part, free_part = raw.to_s.strip.split(";", 2).map { |part| part.to_s.strip }
         free_part = nil if free_part.to_s.empty?

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"
@@ -29,6 +30,7 @@ require_relative "terminal_ui/input_support"
 require_relative "terminal_ui/image_input"
 require_relative "terminal_ui/plain_surface"
 require_relative "terminal_ui/live_region"
+require_relative "terminal_ui/one_shot_sink"
 require_relative "terminal_ui/question_prompt"
 require_relative "terminal_ui/repl_input"
 require_relative "terminal_ui/status_row"
@@ -209,7 +211,9 @@ module Samagotchi
     # follow-up REPL (--non-interactive) or drops into the REPL carrying the
     # post-turn conversation.
     # @return [Symbol, nil] :turn_failed when lines came from a pipe and a
-    #   turn failed (bin/chi exits 1)
+    #   turn failed, :empty_answer when a -p --non-interactive turn ended
+    #   with no answer (bin/chi exits 1 on both), :interrupted when Ctrl-C
+    #   cancelled that turn (bin/chi exits 130)
     def run
       # --non-interactive with no --prompt is a harmless no-op exit: build
       # nothing and return (no transient session, no banner).
@@ -239,25 +243,36 @@ module Samagotchi
       if @prompt && @non_interactive
         # Headless / CI mode: run directly without TTY rendering.
         ArchiveStore.user_input(session.id, state_dir: Session.default_state_dir)
-        result = @engine.run_turn(
-          session,
-          @prompt,
-          on_event: nil,
-          max_iterations: 1000,
-          cancel_controller: nil,
-          images: ImageInput.extract(@prompt)
-        )
+        # Retry lines and hook notices on stderr; stdout gets the answer below.
+        sink = OneShotSink.new
+        begin
+          result = @engine.run_turn(
+            session,
+            @prompt,
+            on_event: sink,
+            max_iterations: IterationLimit.for(no_interrupt: true),
+            cancel_controller: nil,
+            images: ImageInput.extract(@prompt)
+          )
+        rescue LLM::ProviderError, ImageStore::Error => e
+          return one_shot_failed(session, e)
+        rescue Interrupt
+          return one_shot_interrupted(session)
+        end
         # No answer (the empty-answer retries used up): no text, or the chat
         # loop's placeholder (LLM::ModelResult#empty_answer?).
         if result.empty_answer?
-          # Nothing to print: say so on stderr and fail, so a script that
-          # pipes the answer doesn't take the silence for one.
+          # Nothing to print: say so on stderr and fail (bin/chi exits 1),
+          # so a script that pipes the answer doesn't take the silence for one.
           session.save
           warn EMPTY_ANSWER_ERROR
-          exit 1
+          sink.flush
+          return :empty_answer
         end
         @surface.commit(result.output)
         session.save
+        # The after_turn hooks' notices, after the answer as the REPL shows them.
+        sink.flush
         return
       end
 
@@ -285,6 +300,18 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
+    # A -p --non-interactive turn that failed (bin/chi exits 1): the error,
+    # then how to go on. The Engine saved the failed turn with its prompt,
+    # so the session is kept and `chi --resume` takes it up again.
+    # @return [Symbol] :turn_failed
+    def one_shot_failed(session, error)
+      warn "Error: #{error.respond_to?(:summary) ? error.summary : error.message}"
+      if !@scratch && Session.exist?(session.id)
+        warn "chi: the session is kept with your prompt; continue it with: chi --resume #{session.id}"
+      end
+      :turn_failed
+    end
+
     # `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.
@@ -301,6 +328,19 @@ module Samagotchi
       :turn_failed if result.status == :error
     end
 
+    # Ctrl-C in a -p --non-interactive turn: the Engine kept the prompt and
+    # a cancel note in the session (it saves only a failed turn), so save
+    # it here: `chi --resume` takes it up again. A scratch session goes in
+    # #run's ensure, so there is nothing to keep.
+    # @return [Symbol] :interrupted
+    def one_shot_interrupted(session)
+      return :interrupted if @scratch
+
+      session.save
+      warn "chi: canceled (Ctrl-C); the session is kept: continue it with chi --resume #{session.id}"
+      :interrupted
+    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:)
@@ -399,19 +439,29 @@ module Samagotchi
       system_message = { role: "system", content: seed_system_prompt }
       if @resume_session
         messages = ContextNote.with_system_head(session.messages.dup, system_message)
-        @surface.commit("Resumed session: #{session.id}")
+        banner("Resumed session: #{session.id}")
         saved = @engine.saved_recap
-        @surface.commit(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
+        banner(recap_block(saved[:text], turns_since: saved[:turns_since])) if saved
       elsif @scratch
         messages = [system_message]
-        @surface.commit("Scratch session: nothing is kept, it is deleted when you leave.")
+        banner("Scratch session: nothing is kept, it is deleted when you leave.")
       else
         messages = [system_message]
-        @surface.commit("Session: #{session.id}")
+        banner("Session: #{session.id}")
       end
       messages
     end
 
+    # A line about the session, not the answer: on stderr in a
+    # --non-interactive run, whose stdout is the answer's alone (a script
+    # or a parent agent reads it), and before the turn, so it comes first.
+    def banner(text)
+      return @surface.commit(text) unless @non_interactive
+
+      $stderr.puts(text)
+      $stderr.flush
+    end
+
     # Interactive REPL loop. Session seed + messages are built by #run and
     # threaded in here (so --prompt / --resume share one code path). The
     # session's conversation is the single working copy: turns go through
@@ -485,7 +535,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
@@ -655,6 +705,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)
@@ -941,6 +994,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?
 

data/lib/samagotchi/tool_declarations.rb

@@ -18,7 +18,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.",
+        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.",
         parameters: {
           type: "object",
           properties: {
@@ -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"]
@@ -153,7 +153,7 @@ module Samagotchi
       },
       {
         name: "task_create",
-        description: "Start a background task for a long-running shell command. Returns task id and output path for later inspection.",
+        description: "Start a background task for a long-running shell command. Servers and anything meant to keep running belong here, not in execute with &. Returns task id and output path for later inspection.",
         parameters: {
           type: "object",
           properties: {

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,21 @@ 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)"
+      # How long the output may stay open once the shell has exited: a
+      # `server &` child keeps the pipes, and the read would never end.
+      BACKGROUND_GRACE_SEC = 1.5
+      BACKGROUND_HINT = "(a background process kept the output open and was stopped; " \
+                        "to keep a server or long job running, start it with task_create)"
+      # It had left the process group (setsid), so it is still running.
+      BACKGROUND_DETACHED_HINT = "(a background process kept the output open and was left running; " \
+                                 "to keep a server or long job running, start it with task_create)"
+      READ_CHUNK_BYTES = 65_536
 
       def self.name        = NAME
 
@@ -34,7 +44,7 @@ module Samagotchi
         return "Error: cwd not found: #{resolved_cwd}" unless resolved_cwd
 
         timeout_sec = timeout_seconds
-        stdout, stderr, status = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
+        stdout, stderr, status, held_open = run_command(command, timeout_sec: timeout_sec, cwd: resolved_cwd, cancelled: cancelled,
                                                       env: env)
 
         stdout_block = output_block("stdout", stdout)
@@ -49,11 +59,12 @@ module Samagotchi
         # model as "done, something happened".
         silent = stdout_block.nil? && stderr_block.nil?
         parts << (silent ? "exit: #{status.exitstatus} (no output)" : "exit: #{status.exitstatus}")
+        parts << (held_open == :detached ? BACKGROUND_DETACHED_HINT : BACKGROUND_HINT) if held_open
         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
@@ -74,13 +85,14 @@ module Samagotchi
         status = nil
         timed_out = false
         was_cancelled = false
+        aborted = false
+        held_open = false
         started = monotonic_time
         deadline = started + timeout_sec
 
         Open3.popen3(env || {}, command, chdir: cwd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
           stdin.close
-          stdout_reader = reader_thread_for(stdout)
-          stderr_reader = reader_thread_for(stderr)
+          readers = [OutputReader.new(stdout), OutputReader.new(stderr)]
 
           begin
             until wait_thr.join(WAIT_SLICE_SEC)
@@ -99,36 +111,103 @@ module Samagotchi
             # An Interrupt (or anything else) mid-wait: the child is in its own
             # process group, so it never saw the SIGINT. Kill it, or the reads
             # below block until it closes stdout.
+            aborted = true
             terminate_process_tree(wait_thr.pid)
             raise
           ensure
-            # Read the buffered output before closing the pipes. For a process
-            # that exits almost instantly (e.g. `echo hello`), the background
-            # reader thread may not have scheduled its `io.read` yet; joining
-            # the reader after the pipe is closed would return "".
-            stdout_text = stdout_reader.value
-            stderr_text = stderr_reader.value
-            close_quietly(stdout)
-            close_quietly(stderr)
+            # The shell is gone, but a child it put in the background (`cmd &`)
+            # may still hold the pipes: wait for EOF a short grace only, then
+            # stop the command's process group and keep the output so far.
+            # Already stopped (timeout, Stop, an exception): no more checks.
+            stopping = timed_out || was_cancelled || aborted
+            outcome = await_readers(readers, until_time: monotonic_time + BACKGROUND_GRACE_SEC,
+                                             deadline: stopping ? nil : deadline,
+                                             cancelled: stopping ? -> { false } : cancelled)
+            unless outcome == :done
+              was_cancelled = true if outcome == :cancelled
+              timed_out = true if outcome == :timeout
+              stopped = stop_process_group(wait_thr.pid, readers)
+              held_open = (stopped ? :stopped : :detached) if outcome == :grace && !stopping
+            end
+            readers.each(&:finish)
+            stdout_text, stderr_text = readers.map(&:text)
           end
         end
 
         raise CommandTimedOut.new(stdout_text, stderr_text) if timed_out
         raise CommandCancelled.new(stdout_text, stderr_text, monotonic_time - started) if was_cancelled
 
-        [stdout_text, stderr_text, status]
+        [stdout_text, stderr_text, status, held_open]
       end
       private_class_method :run_command
 
-      def self.reader_thread_for(io)
-        Thread.new do
-          Thread.current.report_on_exception = false
-          io.read.to_s
-        rescue IOError, EOFError
-          ""
+      # Waits for both readers to hit EOF until +until_time+, the overall
+      # +deadline+ or a Stop. Returns :done, :grace, :timeout or :cancelled.
+      def self.await_readers(readers, until_time:, deadline:, cancelled:)
+        loop do
+          return :done if readers.all?(&:done?)
+          return :cancelled if cancelled.call
+          return :timeout if deadline && monotonic_time > deadline
+          return :grace if monotonic_time > until_time
+
+          readers.find { |r| !r.done? }&.wait(STOP_POLL_INTERVAL_SEC)
+        end
+      end
+      private_class_method :await_readers
+
+      # The shell has exited (its pid is reaped) but its process group still
+      # has members holding the output: TERM the group, then KILL it. A process
+      # that left the group (setsid) is out of reach; the pipes get closed.
+      # True once the output was released, false if something still holds it.
+      def self.stop_process_group(pgid, readers)
+        signal_group(pgid, "TERM")
+        return true if await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil,
+                                              cancelled: -> { false }) == :done
+
+        signal_group(pgid, "KILL")
+        await_readers(readers, until_time: monotonic_time + STOP_GRACE_SEC, deadline: nil, cancelled: -> { false }) == :done
+      end
+      private_class_method :stop_process_group
+
+      # Only the group: the leader's pid is reaped, so it may name another process.
+      def self.signal_group(pgid, signal)
+        Process.kill(signal, -pgid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+      private_class_method :signal_group
+
+      # Reads a pipe in chunks on its own thread, so the output read so far
+      # survives the pipe being closed under it.
+      class OutputReader
+        def initialize(io)
+          @io = io
+          @buffer = String.new(encoding: Encoding::BINARY)
+          @thread = Thread.new do
+            Thread.current.report_on_exception = false
+            loop { @buffer << io.readpartial(READ_CHUNK_BYTES) }
+          rescue EOFError, IOError
+            nil
+          end
+        end
+
+        def done? = !@thread.alive?
+
+        def wait(seconds) = @thread.join(seconds)
+
+        # Closes the pipe (a reader still blocked gets IOError) and ends the
+        # thread; the text is safe to read afterwards.
+        def finish
+          @thread.join(STOP_POLL_INTERVAL_SEC) unless done?
+          Execute.send(:close_quietly, @io)
+          @thread.kill unless @thread.join(STOP_GRACE_SEC)
+        end
+
+        def text
+          @buffer.dup.force_encoding(@io.external_encoding || Encoding.default_external)
         end
       end
-      private_class_method :reader_thread_for
+      private_constant :OutputReader
 
       def self.close_quietly(io)
         io.close unless io.closed?

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/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.17.0"
+  VERSION = "0.18.1"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end