samagotchi 0.17.0 → 0.18.0

data/lib/samagotchi/parent_report.rb

@@ -31,8 +31,10 @@ module Samagotchi
     module_function
 
     # @param result [ReplyWait::Result]
-    # @return [String] answered, question, failed, canceled, no_answer,
-    #   error, worker_gone, stopped or running
+    # @return [String] answered, question, failed, canceled, limit (the
+    #   turn ran out of iterations, nobody asked), not_continued (a Stop
+    #   answered the step-limit question), no_answer, error, worker_gone,
+    #   stopped or running
     def status(result)
       case result.status
       when :done then "answered"
@@ -41,6 +43,8 @@ module Samagotchi
         case result.outcome
         when "failed" then "failed"
         when "canceled" then "canceled"
+        when "exhausted" then "limit"
+        when "not_continued" then "not_continued"
         else "no_answer"
         end
       when :error then "error"
@@ -52,11 +56,12 @@ module Samagotchi
       end
     end
 
-    # @return [Integer] 0 answered, 3 a question waits, 4 still running,
-    #   1 anything else
+    # @return [Integer] 0 answered (or not continued: the Stop asked for
+    #   was carried out), 3 a question waits, 4 still running, 1 anything
+    #   else
     def exit_status(result)
       case status(result)
-      when "answered" then CLI::Exit::OK
+      when "answered", "not_continued" then CLI::Exit::OK
       when "question" then CLI::Exit::QUESTION
       when "running" then CLI::Exit::RUNNING
       else CLI::Exit::FAILED
@@ -116,7 +121,8 @@ module Samagotchi
 
     # A pending question (Session#pending_question) as a parent sees it.
     # kind is "question" for the model's own (the desk stores none),
-    # "hook" or "approval".
+    # "hook", "approval" or "continue" (the step-limit question, with the
+    # turn's limit).
     # @return [Hash]
     def question(pending)
       pending ||= {}
@@ -129,15 +135,18 @@ module Samagotchi
         options: Array(pending[:options]).map(&:to_s),
         multi_select: !!pending[:multi_select],
         allow_freeform: !!pending[:allow_freeform],
+        limit: pending[:limit],
         approval: approval&.slice(*APPROVAL_KEYS)
       }.compact
     end
 
     # The command that answers +question+; N is the parent's to fill in.
     # An approval's is a deny: allowing it is the user's
-    # (Guardrails::ParentApprovals).
+    # (Guardrails::ParentApprovals). A step-limit question's continues the
+    # turn (its Stop form is in #question_text).
     def answer_with(session_id, question)
       return "chi answer #{session_id} --question #{question[:id]} --option Deny --text WHY" if approval?(question)
+      return "chi answer #{session_id} --question #{question[:id]} --option Continue" if continue?(question)
 
       "chi answer #{session_id} --question #{question[:id]} --option N"
     end
@@ -156,6 +165,16 @@ module Samagotchi
       question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "approval"
     end
 
+    # The step-limit question (ContinueOffer).
+    def continue?(question)
+      question.is_a?(Hash) && (question[:kind] || question["kind"]).to_s == "continue"
+    end
+
+    # What a message does to a step-limit question.
+    def message_drops(session_id)
+      "a message instead (chi send #{session_id} -m …) drops it and starts a new turn"
+    end
+
     # What a wait that ended without an answer says, one line.
     def detail(result, session_id:, timeout: nil)
       attach = "chi --attach #{session_id}"
@@ -163,10 +182,13 @@ module Samagotchi
       when :waiting_for_answer
         if approval?(result.question)
           "waiting for an approval: #{first_line(result.question[:question])}; #{DENY_AND_TELL}"
+        elsif continue?(result.question)
+          "waiting at the step limit: #{first_line(result.question[:question])}; " \
+            "answer Continue or Stop: chi answer #{session_id} --question #{result.question[:id]} --option Continue"
         else
           "waiting for an answer: #{first_line(result.question&.dig(:question))}; open it: #{attach} or the web"
         end
-      when :no_reply then "#{no_reply_line(result)}; #{attach} shows it"
+      when :no_reply then "#{no_reply_line(result, session_id)}; #{attach} shows it"
       when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
       when :worker_gone then "the worker is gone; #{attach} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
@@ -188,6 +210,10 @@ module Samagotchi
         lines << "  allowing it is up to your user: #{DENY_AND_TELL}"
         lines << "  deny: #{answer_with(session_id, q)}"
         lines << "  #{leave_open(session_id)}"
+      elsif continue?(q)
+        lines << "  continue: #{answer_with(session_id, q)}"
+        lines << "  stop: chi answer #{session_id} --question #{q[:id]} --option Stop --text WHY (the text is optional; the model reads it)"
+        lines << "  #{message_drops(session_id)}"
       else
         lines << "  more than one allowed: repeat --option" if q[:multi_select]
         lines << "  free text allowed: --text" if q[:allow_freeform]
@@ -197,11 +223,15 @@ module Samagotchi
       lines.map { |line| "#{line}\n" }.join
     end
 
-    def no_reply_line(result)
+    def no_reply_line(result, session_id = nil)
       case result.outcome
       when "failed" then result.text.to_s.strip.empty? ? "the turn failed" : "the turn failed: #{result.text.strip}"
       when "canceled" then "the turn was canceled"
       when "completed" then "the turn ended with no visible answer"
+      when "not_continued" then "the turn was not continued (Stop); its work so far stays"
+      when "exhausted"
+        "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered; " \
+          "chi send #{session_id} -m '/continue yes' continues it, a message drops it"
       else "the turn ended without a reply (canceled, failed or empty)"
       end
     end

data/lib/samagotchi/question_desk.rb

@@ -8,6 +8,7 @@ require "time"
 require_relative "log"
 require_relative "tools/ask_user_question"
 require_relative "guardrails/parent_approvals"
+require_relative "guardrails/parent_continue"
 
 module Samagotchi
   # An Engine's question flow: the one open question (ask_user_question, a
@@ -15,6 +16,15 @@ module Samagotchi
   # by every UI. The turn thread blocks in #open_question; the UIs answer or
   # cancel from theirs (a REPL answers inline through the sync handler).
   #
+  # A standing question (#post: a worker's step-limit question, kind
+  # "continue") blocks nobody: it waits between turns, its answer goes to
+  # its on_answer, and its poster withdraws it (#withdraw). It can't be
+  # dismissed. One question stays pending at a time: a question opened
+  # while one stands supersedes it (withdrawn, reason "superseded"), and
+  # once that one closes the standing one is offered again
+  # (on_superseded_close); one posted while another is open waits for it
+  # the same way.
+  #
   # What it needs from the Engine comes through lookups, read at call time.
   class QuestionDesk
     # Raised by #answer when the question it targets is no longer open
@@ -24,18 +34,28 @@ module Samagotchi
 
     # Raised by #answer when a parent agent's answer (chi answer's client
     # id) allows an approval further than this worker's
-    # guardrails.parent_approvals lets it (Guardrails::ParentApprovals).
-    # The question stays open; transports map it to 403.
+    # guardrails.parent_approvals lets it (Guardrails::ParentApprovals), or
+    # continues a turn turn.parent_continue keeps it from
+    # (Guardrails::ParentContinue). The question stays open; transports map
+    # it to 403.
     class Refused < StandardError
-      # @return [Symbol] :off or :once_only
+      # @return [Symbol] :off, :once_only, :protected or :stop_only
       attr_reader :reason
 
       def initialize(reason)
         @reason = reason
-        super("a parent may not allow this approval (#{reason})")
+        super(reason == :stop_only ? "a parent may not continue this turn" : "a parent may not allow this approval (#{reason})")
       end
     end
 
+    # Raised by #cancel for a standing question (#post): its poster closes
+    # it, an answer settles it. Transports map it to 409 not_dismissable.
+    class NotDismissable < StandardError; end
+
+    # A step-limit question's options (kind "continue").
+    CONTINUE_KIND = "continue"
+    CONTINUE_OPTION = "Continue"
+
     # Seconds between two looks of an open question's watch (#open_question).
     WATCH_INTERVAL = 0.5
 
@@ -62,6 +82,11 @@ module Samagotchi
       @pending = nil
       @answer = nil
       @sync_handler = nil
+      # The standing question while it is @pending: {id:, fields:,
+      # on_answer:, on_superseded_close:}; @shelved, one superseded by (or
+      # posted during) another question, offered again when that closes.
+      @standing = nil
+      @shelved = nil
     end
 
     # @return [Hash, nil] current pending question (thread-safe copy)
@@ -99,23 +124,68 @@ module Samagotchi
     # @return [Hash, String] the answer {id:, selected:, freeform:, selected_indices:},
     #   or {error:, …}; a String when a sync handler returned text itself
     def open_question(fields, watch: nil)
-      id = SecureRandom.uuid
-      pending = { id: id, **fields, status: "pending", created_at: Time.now.iso8601(3) }.compact
+      supersede_standing
+      ask(fields, watch)
+    ensure
+      offer_shelved
+    end
 
-      @lock.synchronize do
-        @pending = pending
-        @answer = nil
+    # Publish a standing question: pending (saved, announced with
+    # standing: true) without blocking anyone. An answer to it is checked
+    # as any other and handed to +on_answer+ (answer, client_id:) on the
+    # answering thread, after it is cleared and :question_answered is out.
+    # Posted while another question is open, it waits for that one to
+    # close (as a superseded one does). A standing one already up is
+    # replaced (withdrawn, reason "replaced").
+    # @param fields [Hash] as for #open_question
+    # @param on_answer [#call] (answer, client_id:)
+    # @param on_superseded_close [#call, nil] called when a question that
+    #   superseded it closes (its poster posts it again if it still
+    #   stands); nil: posted again as it was
+    # @return [Hash, nil] the pending question; nil when it waits for another
+    def post(fields, on_answer:, on_superseded_close: nil)
+      standing = { fields: fields, on_answer: on_answer, on_superseded_close: on_superseded_close }
+      shelved = @lock.synchronize do
+        next false unless @pending && !@standing
+
+        @shelved = standing
+        true
       end
-      # Persist to session file for WEB stub + resume (generic for all UIs)
-      if session
-        session.pending_question = pending.dup
-        begin; session.save(state_dir: state_dir); rescue StandardError; nil; end
+      return nil if shelved
+
+      withdraw("replaced")
+      publish(fields, standing: standing)
+    end
+
+    # Withdraw the standing question (its poster's close: the offer went,
+    # was answered by a command, the worker leaves), announced as
+    # :question_cancelled with +reason+. A shelved one just goes.
+    # @param id [String, nil] only this one
+    # @return [Boolean] whether one was pending
+    def withdraw(reason, id: nil)
+      withdrawn = @lock.synchronize do
+        @shelved = nil if id.nil?
+        standing = @standing
+        next nil unless standing && @pending && @pending[:id] == standing[:id]
+        next nil if id && standing[:id].to_s != id.to_s
+
+        @standing = nil
+        @pending = nil
+        standing[:id]
       end
-      # Generic emit for all UIs (TUI, WEB, Bridge, future). Observers that
-      # stash this event (e.g. TerminalUI handle_question_event) will
-      # discard it as stale if the synchronous handler below already answers
-      # and clears pending — see drain_pending_question? staleness check.
-      emit({ type: :question_requested, pending_question: pending })
+      return false unless withdrawn
+
+      clear_saved_question
+      emit({ type: :question_cancelled, id: withdrawn, reason: reason.to_s })
+      true
+    end
+
+    # @return [Boolean] the pending question is a standing one
+    def standing? = @lock.synchronize { !@standing.nil? }
+
+    private def ask(fields, watch)
+      pending = publish(fields)
+      id = pending[:id]
 
       # If a synchronous UI handler is registered (TUI), invoke it inline on the
       # SAME thread that called request_question (TerminalUI's REPL thread is the
@@ -202,7 +272,9 @@ module Samagotchi
       parent_agent = client_id.to_s == Guardrails::ParentApprovals::CLIENT_ID if parent_agent.nil?
       # Read before the lock (config may touch the disk); this worker's own.
       parent_setting = Guardrails::ParentApprovals.setting if parent_agent
-      @lock.synchronize do
+      parent_continue = Guardrails::ParentContinue.allowed? if parent_agent
+      standing = nil
+      answer = @lock.synchronize do
         pending = @pending
         raise NotPending, "no pending question" unless pending
         raise NotPending, "id mismatch" unless pending[:id].to_s == id.to_s
@@ -212,37 +284,25 @@ module Samagotchi
         raise NotPending, "question already answered" if @answer
         raise NotPending, "question #{pending[:status]}" unless pending[:status].to_s == "pending"
 
-        opts = Array(pending[:options])
-        # Validate selected subset of options (value == label in v1)
-        invalid = sel.reject { |v| opts.include?(v) }
-        unless invalid.empty?
-          raise ArgumentError, "invalid selection: #{invalid.join(', ')} (valid: #{opts.join(', ')})"
+        answer = validated_answer(pending, sel, fm, parent_agent: parent_agent, parent_setting: parent_setting)
+        if parent_agent && (reason = Guardrails::ParentContinue.refusal(pending, sel, allowed: parent_continue))
+          raise Refused, reason
         end
-        if !pending[:multi_select] && sel.size > 1
-          raise ArgumentError, "single-select question: got #{sel.size} selections"
+        if @standing
+          # No waiter: cleared here, so a second answer finds none.
+          standing = @standing
+          @standing = nil
+          @pending = nil
+        else
+          @answer = answer
+          @cv.broadcast
         end
-        if pending[:multi_select] == false && sel.empty? && fm.nil?
-          raise ArgumentError, "selection required"
-        end
-        indices = sel.map { |v| opts.index(v) }
-        # Checked against the question pending now, under the lock: the one
-        # whose answer settles the approval (Approval.settle, by index).
-        if parent_setting
-          reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: parent_setting)
-          raise Refused, reason if reason
-        end
-        # Persist pending cleared elsewhere; just set answer
-        answer = { id: id.to_s, selected: sel, freeform: fm }
-        # Derive indices for convenience
-        answer[:selected_indices] = indices.compact
-        answer[:by] = "parent_agent" if parent_agent
-        @answer = answer
-        @cv.broadcast
         answer
-      end.tap do
-        # A human answered: the session is back in the lists (ArchiveStore).
-        @user_input.call(session&.id) unless parent_agent
       end
+      settle_standing(standing, answer, client_id) if standing
+      # A human answered: the session is back in the lists (ArchiveStore).
+      @user_input.call(session&.id) unless parent_agent
+      answer
     end
 
     # Mark the pending question as relayed to a parent session's user, or
@@ -287,12 +347,16 @@ module Samagotchi
     #   names the one it showed)
     # @return [Boolean] whether it was cancelled (true with none pending and
     #   no id, as before)
+    # @raise [NotDismissable] +id+ names a standing question (#post)
     def cancel(reason = "user", id: nil)
       cancelled_id = @lock.synchronize do
         pending = @pending
         next unless pending
         next if id && pending[:id].to_s != id.to_s
         next if @answer || pending[:status].to_s != "pending"
+        # Its poster closes it; nothing waits on a cancel.
+        raise NotDismissable, "answer #{Array(pending[:options]).join(' or ')}" if @standing && id
+        next if @standing
 
         pending[:status] = "cancelled"
         @cv.broadcast
@@ -330,6 +394,101 @@ module Samagotchi
 
     private
 
+    # Make +fields+ the pending question: set under the lock, saved to the
+    # session file (the web's stub, a resume, the lists) and announced as
+    # :question_requested to every UI. Observers that stash the event (e.g.
+    # TerminalUI handle_question_event) discard it as stale if a sync
+    # handler answers and clears it first (drain_pending_question?).
+    # @return [Hash] the pending question
+    # @param standing [Hash, nil] a standing question's record (#post)
+    def publish(fields, standing: nil)
+      pending = { id: SecureRandom.uuid, **fields, status: "pending", created_at: Time.now.iso8601(3) }.compact
+      @lock.synchronize do
+        @pending = pending
+        @answer = nil
+        @standing = standing&.merge(id: pending[:id])
+      end
+      if session
+        session.pending_question = pending.dup
+        begin; session.save(state_dir: state_dir); rescue StandardError; nil; end
+      end
+      event = { type: :question_requested, pending_question: pending }
+      event[:standing] = true if standing
+      emit(event)
+      pending
+    end
+
+    # A question is about to open: a standing one gives way (withdrawn,
+    # reason "superseded") and is shelved until the new one closes.
+    def supersede_standing
+      standing = @lock.synchronize do
+        next nil unless @standing
+
+        @shelved = @standing
+        @standing = nil
+        @pending = nil
+        @shelved[:id]
+      end
+      emit({ type: :question_cancelled, id: standing, reason: "superseded" }) if standing
+    end
+
+    # The question that superseded a standing one closed: offer it again.
+    def offer_shelved
+      shelved = @lock.synchronize do
+        next nil if @pending || @shelved.nil?
+
+        @shelved.tap { @shelved = nil }
+      end
+      return unless shelved
+
+      if shelved[:on_superseded_close]
+        shelved[:on_superseded_close].call
+      else
+        post(shelved[:fields], on_answer: shelved[:on_answer])
+      end
+    rescue StandardError => e
+      Log.warn(:turn, "standing_question_repost_failed", error: e.class.name, message: e.message)
+    end
+
+    # A standing question's answer: cleared from the file, announced, then
+    # handed to its poster with who answered.
+    def settle_standing(standing, answer, client_id)
+      clear_saved_question
+      emit({ type: :question_answered, id: answer[:id], answer: answer })
+      standing[:on_answer].call(answer.except(:by), client_id: client_id)
+    rescue StandardError => e
+      Log.warn(:turn, "standing_answer_failed", error: e.class.name, message: e.message)
+    end
+
+    # An answer to +pending+, checked: the selections are its options (value
+    # == label in v1), one for a single-select, one or a text when required,
+    # and a parent agent's within guardrails.parent_approvals. Under the
+    # question lock: checked against the question pending now.
+    # @return [Hash] {id:, selected:, freeform:, selected_indices:, by:}
+    # @raise [ArgumentError, Refused]
+    def validated_answer(pending, sel, fm, parent_agent:, parent_setting:)
+      opts = Array(pending[:options])
+      invalid = sel.reject { |v| opts.include?(v) }
+      raise ArgumentError, "invalid selection: #{invalid.join(', ')} (valid: #{opts.join(', ')})" unless invalid.empty?
+      raise ArgumentError, "single-select question: got #{sel.size} selections" if !pending[:multi_select] && sel.size > 1
+      raise ArgumentError, "selection required" if pending[:multi_select] == false && sel.empty? && fm.nil?
+      # A step-limit question: Continue resumes the turn as it was; a text
+      # goes with Stop (steering a continue is not a thing).
+      if pending[:kind].to_s == CONTINUE_KIND && sel == [CONTINUE_OPTION] && fm
+        raise ArgumentError, "Continue takes no text (a text goes with Stop)"
+      end
+
+      indices = sel.map { |v| opts.index(v) }
+      # The one whose answer settles the approval (Approval.settle, by index).
+      if parent_setting
+        reason = Guardrails::ParentApprovals.refusal(pending, indices, setting: parent_setting)
+        raise Refused, reason if reason
+      end
+      answer = { id: pending[:id].to_s, selected: sel, freeform: fm, selected_indices: indices.compact }
+      answer[:by] = "parent_agent" if parent_agent
+      answer
+    end
+
     # Wait until the question is answered, cancelled or closed by +watch+.
     # @return [String, nil] the watch's close reason
     def wait_for_answer(watch)

data/lib/samagotchi/reply_wait.rb

@@ -26,10 +26,14 @@ module Samagotchi
     # @!attribute question [Hash, nil] the pending question
     #   (:waiting_for_answer)
     # @!attribute outcome [String, nil] how the turn ended when it left no
-    #   reply (:no_reply): "failed", "canceled" or "completed" (empty), from
-    #   the session's last_turn; nil when unknown. With "failed", text is
-    #   the failure's summary when the turn note has one.
-    Result = Struct.new(:status, :text, :file, :question, :outcome, keyword_init: true)
+    #   reply (:no_reply): "failed", "canceled", "completed" (empty),
+    #   "exhausted" (it ran out of iterations, with nobody asked whether to
+    #   continue) or "not_continued" (a Stop answered the step-limit
+    #   question; no turn ran), from the session's last_turn; nil when unknown. With
+    #   "failed", text is the failure's summary when the turn note has one.
+    # @!attribute limit [Integer, nil] the iteration limit an "exhausted"
+    #   turn ran out at
+    Result = Struct.new(:status, :text, :file, :question, :outcome, :limit, keyword_init: true)
 
     module_function
 
@@ -144,6 +148,8 @@ module Samagotchi
       last = session.last_turn.is_a?(Hash) ? session.last_turn : {}
       fresh = baseline.nil? || !baseline.key?(:last_turn) || (last["ended_at"] && last["ended_at"] != baseline[:last_turn])
       outcome = fresh ? last["outcome"] : nil
+      return Result.new(status: :no_reply, outcome: "exhausted", limit: last["limit"]) if fresh && last["exhausted"]
+
       text = outcome == "failed" ? failure_summary(session.messages) : nil
       Result.new(status: :no_reply, outcome: outcome, text: text)
     end

data/lib/samagotchi/send_command.rb

@@ -66,7 +66,8 @@ module Samagotchi
                     (--wait) one JSON object on stdout, whatever the end:
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
-                    no_answer, error, worker_gone, stopped, command (detail)
+                    limit, no_answer, error, worker_gone, stopped,
+                    command (detail)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
         question waits, 4 still running (--timeout), 130 Ctrl-C.
         Only sessions on this machine. Answers show in the attached TUI

data/lib/samagotchi/session.rb

@@ -100,7 +100,8 @@ module Samagotchi
     end
 
     # The question this session waits on, as the lists show it: {id:, kind:}
-    # with kind "question" (the model's), "approval" or "hook"; nil with
+    # with kind "question" (the model's), "approval", "hook" or "continue"
+    # (the step-limit question, asked between turns); nil with
     # none. Only while a worker runs it (+live+): a question saved by a
     # worker that died waits for no one (the next worker drops it). The
     # web's summaries and `chi sessions list` both ask this.
@@ -113,7 +114,7 @@ module Samagotchi
       kind = pending[:kind].to_s
       relayed = pending[:relayed_to]
       relayed_to = relayed.is_a?(Hash) ? (relayed[:parent_short] || relayed["parent_short"]) : nil
-      { id: pending[:id], kind: %w[approval hook].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
+      { id: pending[:id], kind: %w[approval hook continue].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
     end
 
     # The stored project root, else (a file from before the field) the

data/lib/samagotchi/session_commands.rb

@@ -158,11 +158,11 @@ module Samagotchi
                when :abort
                  @turn_flow.abort_continue!
                  save_session
-                 reply("interrupted turn cancelled; enter your next prompt", changed: [:messages])
+                 reply("turn not continued; its work so far stays (!rollback erases it)", changed: [:messages])
                when :abort_with_reason
                  @turn_flow.abort_continue!(reason: reason)
                  save_session
-                 reply("interrupted turn cancelled; noted your explanation", changed: [:messages])
+                 reply("turn not continued; noted your reason", changed: [:messages])
                else
                  reply("answer yes, no, or no, <reason>", status: :error)
                end
@@ -252,6 +252,7 @@ module Samagotchi
           ("tool #{rule.tools.join(",")}" if rule.tools),
           ("command /#{shorten_pattern(rule.command.source)}/" if rule.command),
           ("path #{rule.path}" if rule.path),
+          ("git #{rule.git}" if rule.git),
           ("models #{rule.models.join(",")}" if rule.models)
         ].compact.join(", ")
         off = "disabled (guardrails.disable) — " if rules.disabled?(rule)

data/lib/samagotchi/session_manager.rb

@@ -364,7 +364,10 @@ module Samagotchi
       cut(summary_text(session), SUMMARY_PREVIEW_LIMIT)
     end
 
-    private_class_method def self.summary_text(session)
+    # A session as one line of text for the lists: its last prompt, else the
+    # first message it was started with (a session command like `/model x`,
+    # or a first turn not saved yet).
+    def self.summary_text(session)
       one_line(session.last_prompt.to_s.strip.empty? ? session.first_preview.to_s : session.last_prompt.to_s)
     end
 

data/lib/samagotchi/sessions_command.rb

@@ -191,11 +191,12 @@ module Samagotchi
       order ||= "desc"
       sessions = Samagotchi::SessionManager.list_sessions(sort: sort, order: order, limit: limit, project_root: project,
                                                           include_archived: include_archived)
-      # The saved recap's first sentence, else the last prompt, cut as before.
+      # The saved recap's first sentence, else the last prompt (or the first
+      # message, before any turn), cut as before.
       state_dir = Samagotchi::Session.default_state_dir
       list_text = lambda do |s|
         recap = Samagotchi::RecapStore.preview(Samagotchi::Session.session_dir(s.id, state_dir: state_dir))
-        (recap || Samagotchi::SessionManager.one_line(s.last_prompt))[0, 60]
+        (recap || Samagotchi::SessionManager.summary_text(s))[0, 60]
       end
       # A delegated session points at its parent: ↳ <parent's short id>.
       row = lambda do |s|

data/lib/samagotchi/system_prompt.rb

@@ -381,7 +381,7 @@ module Samagotchi
       root = MemoryPaths.project_root(cwd)
       lines = ["Current working directory:", cwd]
       unless root == cwd
-        lines << "Project root (project memories are shared by all worktrees and subdirectories of this repository):"
+        lines << "Project root (only where shared project memories come from; read, edit, run and commit in the current working directory above):"
         lines << root
       end
       home = Dir.home

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -342,6 +342,9 @@ module Samagotchi
           # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
           persist_recent_history(text) if PromptHistory.shell_line?(text)
           send_command(text)
+        elsif (hint = command_registry.unknown_command_hint(text))
+          # A typo of a command (/modle) is not a prompt: say so, send nothing.
+          @screen.commit(hint)
         else
           send_prompt(text)
         end
@@ -522,6 +525,9 @@ module Samagotchi
       # UI's answer shows as its command line (web> /continue yes) instead.
       def continue_resolved(event)
         @continue_offer = nil
+        # Asked as the step-limit question: its line says what became of it.
+        asked = @offer_asked
+        @offer_asked = false
         sync_continue_slot
         who = event[:client_id] ? CLIENT_LABELS.fetch(event[:client_id].to_s.split(":", 2).first, "another UI") : "another UI"
         outcome = if event[:decision] == "dropped"
@@ -530,14 +536,14 @@ module Samagotchi
                     @continue_answer || CONTINUE_DECISIONS.fetch(event[:decision].to_s, event[:decision].to_s)
                   end
         @continue_answer = nil
-        @screen.commit(QuestionSlot.continue_summary(outcome, paint: method(:paint))) if outcome
+        @screen.commit(QuestionSlot.continue_summary(outcome, paint: method(:paint))) if outcome && !asked
         sync_prompt
       end
 
       # The notes slot shows the offer's choices while it waits (a question
       # has the slot while it is open).
       def sync_continue_slot
-        return if @question
+        return if @question || @offer_asked
 
         if @continue_offer
           @screen.set_slot(:notes, QuestionSlot.continue_offer(@continue_offer[:context], paint: method(:paint)))
@@ -692,6 +698,9 @@ module Samagotchi
         @set_aside = @reader&.typed_text unless @question
         @question = QuestionPrompt.new(pending)
         @question_pending = pending
+        # The step-limit question stands for the continue offer's own slot
+        # until the offer is resolved.
+        @offer_asked = true if @question.continue?
         # An edit's diff goes above, into the scrollback, once per question
         # (a join gets it from the snapshot and may get the event too).
         unless @previewed_id == @question.id
@@ -705,7 +714,9 @@ module Samagotchi
       end
 
       def answer_question(text)
-        return dismiss_question if text.empty?
+        # Enter alone at the step-limit question continues (it can't be
+        # dismissed), as at the continue prompt.
+        return dismiss_question if text.empty? && !@question.continue?
 
         answer = @question.parse(text)
         @screen.commit(answer.note) if answer.note
@@ -893,6 +904,8 @@ module Samagotchi
           sync_continue_slot
         end
         render_current_turn(snapshot[:current_turn])
+        # A question between turns (the step-limit one) belongs to no turn.
+        ask(snapshot[:pending_question]) if snapshot[:current_turn].nil? && snapshot[:pending_question]
         render_snapshot_cards(cards.select { |card| card[:current] }, joining: !reset)
         Array(snapshot[:queued]).each do |entry|
           next if own?(entry[:client_id])
@@ -951,8 +964,15 @@ module Samagotchi
         return if text.empty?
 
         @screen.commit("#{paint(PROMPT, 92)}#{text}")
-        # As if typed: a session command runs as the command.
-        command_registry.command?(text) ? send_command(text) : send_prompt(text)
+        # As if typed: a session command runs as the command; a typo of one
+        # gets the hint, not a turn.
+        if command_registry.command?(text)
+          send_command(text)
+        elsif (hint = command_registry.unknown_command_hint(text))
+          @screen.commit(hint)
+        else
+          send_prompt(text)
+        end
       end
 
       def render_join_header(messages)