samagotchi 0.16.0 → 0.18.0

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/self_report.rb

@@ -7,6 +7,7 @@ require_relative "context_window"
 require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
+require_relative "model_overlay"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
@@ -39,7 +40,8 @@ module Samagotchi
     end
 
     def fields(env: ENV)
-      model = model_name
+      default = model_name
+      model = session_model(env) || default
       [
         ["version", "#{VERSION} (ruby #{RUBY_VERSION})"],
         ["source", "#{SOURCE_DIR} (#{install_kind})"],
@@ -49,7 +51,8 @@ module Samagotchi
         ["project memories", Tools::MemoryRead.memories_dir("project", env: env)],
         ["sessions", Session.default_state_dir(env: env)],
         ["log", log_path(env)],
-        ["model", model || "(not configured)"],
+        ["model", model ? model_label(model, default, env) : "(not configured)"],
+        ["model key", model ? model_key_for(model, env) : "-"],
         ["host", model ? host_for(model, env) : "-"],
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
@@ -125,6 +128,46 @@ module Samagotchi
       nil
     end
 
+    SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+    PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"
+
+    # The model of the session this chi self runs in (its execute exports
+    # SAMAGOTCHI_SESSION_MODEL, the resolved ref, live after /model); nil
+    # outside a session's commands.
+    def session_model(env)
+      name = env[SESSION_MODEL_ENV].to_s.strip
+      name.empty? ? nil : name
+    end
+
+    # "splash:x (this session abcd1234; default main:y)", "main:y (this
+    # session abcd1234, the default)", or outside a session "main:y (default)".
+    def model_label(model, default, env)
+      return "#{model} (default)" unless session_model(env)
+
+      id = env[PARENT_SESSION_ENV].to_s
+      session = id.empty? || id == "chi" ? "this session" : "this session #{id[0, 8]}"
+      return "#{model} (#{session}, the default)" if default && same_model?(model, default, env)
+
+      "#{model} (#{session}; default #{default || "not configured"})"
+    end
+
+    def same_model?(one, other, env)
+      return true if one == other
+
+      ConfigFile.model_ref(one, env: env).ref == ConfigFile.model_ref(other, env: env).ref
+    rescue StandardError
+      false
+    end
+
+    # The memory overlay key (ModelOverlay.key_for the bare id, as the
+    # engine keys memory_write current_model_only): which `<name>.<key>.md`
+    # overlays are this model's.
+    def model_key_for(model, env)
+      ModelOverlay.key_for(HostRegistry.new(env: env).bare_name(model)) || "-"
+    rescue StandardError
+      ModelOverlay.key_for(model) || "-"
+    end
+
     def model_name
       ModelProfile.required_model_name
     rescue ArgumentError
@@ -147,6 +190,8 @@ module Samagotchi
       entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
     end
 
+    NO_PROPS = "reported per turn (the server has no /props)"
+
     # chi self's one server call: a single-model llama.cpp answers any name
     # with the model it loaded, and its /props names it (model_alias). One
     # GET with the probe's short timeouts; a remote host isn't asked.
@@ -157,10 +202,11 @@ module Samagotchi
       bare = target.bare_model
       return "-" unless entry
       return "reported per turn (remote host)" if entry.remote?
+      return NO_PROPS if entry.chat?
 
       client = registry.client_for(entry)
       props = client.server_props(model: bare)
-      return "reported per turn (the server has no /props)" if props.nil?
+      return NO_PROPS if props.nil? || props.status == :http_error
       return "unknown (the server didn't answer; is it running?)" if props.status == :network_error
 
       served = ServedModel.from_props(props)

data/lib/samagotchi/send_command.rb

@@ -37,6 +37,8 @@ module Samagotchi
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one picks it up. A stopped session's worker starts.
+        A session command (/model x, !cmd) runs as the command; --wait
+        then has no reply to wait for (exit 0, status command).
         -m TEXT     the message; stdin, when piped too, goes above it as a
                     quote (context); without -m, stdin is the message
         --image PATH
@@ -64,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 (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
@@ -246,23 +249,27 @@ module Samagotchi
         error_line("chi send: refused: #{refusal}")
         return 1
       end
+      # With images the web's way: idle (the message names it in the
+      # lists), the images copied in, then the message as a turn. So too a
+      # line that may be a session command (/model x): its worker's answer
+      # says whether it ran as one.
+      through_worker = images || command_like?(prompt)
       begin
-        # With images the web's way: idle (the message names it in the
-        # lists), the images copied in, then the message as a turn.
-        start = images ? { prompt: nil, title: prompt } : { prompt: prompt }
+        start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
         session = SessionManager.spawn_session(**start, working_directory: options[:dir],
                                                         model_name: options[:model], state_dir: @state_dir)
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
       end
-      if images
+      if through_worker
         return 1 unless deliver_new(session, prompt)
       else
         @info.puts("#{session.id}  started")
       end
       @session_id = session.id
       return 0 unless options[:wait]
+      return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
                                  timeout: options[:timeout])
@@ -297,6 +304,7 @@ module Samagotchi
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
       baseline = baseline_of(session)
       return 1 unless deliver(id, prompt)
+      return report_command(id) if @sent_command
 
       wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
     end
@@ -352,10 +360,36 @@ module Samagotchi
         return false
       end
 
-      @info.puts("#{session.id}  started#{with_images}")
+      @sent_command = command_ack?(result[:ack])
+      @info.puts("#{session.id}  started#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 
+    SENT_COMMAND = "sent as a session command"
+
+    # Whether the worker took the message as a session command (a POST
+    # /turn whose line is one answers with its command_id).
+    def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
+
+    # Whether +text+ may be a session command, which only its worker knows
+    # (a bundle's too).
+    def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
+
+    # --wait after a message that ran as a session command: no reply comes
+    # for it. Its output shows where the session is open.
+    # @return [Integer] 0
+    def report_command(id)
+      detail = "#{SENT_COMMAND}: no reply to wait for (its output shows in chi --attach #{id} or the web)"
+      if @json
+        @stdout.puts(JSON.generate({ status: "command", session_id: id, detail: detail }))
+        @stdout.flush
+        @reported = true
+      else
+        @stderr.puts("#{id[0, 8]}  #{detail}")
+      end
+      CLI::Exit::OK
+    end
+
     # @return [Boolean] whether the message was queued
     def deliver(id, prompt)
       short = id[0, 8]
@@ -373,6 +407,12 @@ module Samagotchi
         return false
       end
 
+      @sent_command = command_ack?(result[:ack])
+      if @sent_command
+        @info.puts("#{short}  #{SENT_COMMAND}")
+        return true
+      end
+
       # A busy worker runs a message with images as its own next turn
       # rather than merging it into the running one.
       note = if owner.nil? then " (started its worker)"

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