samagotchi 0.17.0 → 0.18.1

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

@@ -17,16 +17,26 @@ module Samagotchi
       name.is_a?(String) && !name.strip.empty? ? name : nil
     end
 
+    # The separators a provider uses when it decorates a model name: a tag
+    # (`qwen3:latest`), a date or quant suffix (`gpt-4o-2024-08-06`), an
+    # owner (`@org/name`) or a path (`meta-llama/Llama-3`). Anything else
+    # after the name is a different model (`gpt-4` is not `gpt-4o`).
+    EXTENSION_SEPARATORS = [":", "-", "@", "/"].freeze
+
     # Whether +served+ is another model than +asked+. Names that are equal
-    # (any case) or where one extends the other (a provider dropping
-    # `:free`, or adding a date) are the same model; unknown names never
-    # differ.
+    # (any case), or where one extends the other at a tag/date/owner
+    # separator (a provider dropping `:free`, or adding a date), are the
+    # same model; unknown names never differ.
     def differs?(asked, served)
       asked = asked.to_s.strip.downcase
       served = served.to_s.strip.downcase
       return false if asked.empty? || served.empty?
+      return false if asked == served
+
+      shorter, longer = asked.length <= served.length ? [asked, served] : [served, asked]
+      return true unless longer.start_with?(shorter)
 
-      !(asked.start_with?(served) || served.start_with?(asked))
+      !longer[shorter.length..].start_with?(*EXTENSION_SEPARATORS)
     end
   end
 end

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

@@ -237,6 +237,8 @@ module Samagotchi
           end_turn
           own_turn_ended(event)
         when :prompt_restored then restore_prompt(event)
+        # The after_turn hooks are done (their notices came before it).
+        when :answer_display then @display_pending = false
         when :context_status, :used_memories_updated then @status.take_event(event)
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
@@ -342,6 +344,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 +527,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 +538,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)))
@@ -574,9 +582,10 @@ module Samagotchi
         @screen.commit("could not send the prompt (#{worker_down(e)})")
       end
 
-      # Whether the input's end must wait: the -p prompt isn't sent yet, or
-      # a prompt this run sent hasn't had its turn.
-      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty?
+      # Whether the input's end must wait: the -p prompt isn't sent yet, a
+      # prompt this run sent hasn't had its turn, or its turn's after_turn
+      # hooks still run (their notices, source-links' sources:, come next).
+      def own_turns_pending? = !@first_prompt.to_s.strip.empty? || !@open_ids.empty? || @display_pending == true
 
       # A turn ended: this run's prompt (and ours merged into it) had its turn.
       def own_turn_ended(event)
@@ -586,6 +595,8 @@ module Samagotchi
         ours = @open_ids.include?(id) || !@merged_ids.empty?
         @own_failed = true if ours && event[:type] == :turn_failed
         @own_empty = true if ours && event[:type] == :turn_completed && event.dig(:turn_summary, :empty_answer)
+        # The worker sends answer_display once its after_turn hooks ran.
+        @display_pending = true if ours && event[:type] == :turn_completed && event[:display_pending]
         @open_ids.delete(id)
         @open_ids.subtract(@merged_ids)
         @merged_ids.clear
@@ -692,6 +703,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 +719,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 +909,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 +969,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)

data/lib/samagotchi/terminal_ui/one_shot_sink.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+require_relative "event_renderer"
+
+module Samagotchi
+  class TerminalUI
+    # The turn sink of `chi -p … --non-interactive` (Engine#run_turn's
+    # on_event): the few lines a reader wants while the turn runs, on
+    # stderr. stdout is the answer's alone, printed after the turn: a
+    # script or a parent agent reads it.
+    #
+    # It prints the retry lines the REPL shows: the loop asking again after
+    # an empty answer (:empty_answer_retry), and a generation retried after
+    # a failed request (:generation_retrying). And the hooks' notices
+    # (:hook_notice): one during the turn as it comes, one the after_turn
+    # hooks give (after :turn_completed; source-links' `sources:`) kept for
+    # #flush, which the caller runs after it has printed the answer.
+    class OneShotSink
+      include Formatting
+
+      # @param err [IO, nil] nil writes to $stderr as it is at each write
+      def initialize(err: nil)
+        @err = err
+        @turn_over = false
+        @held = []
+      end
+
+      def call(event)
+        case event[:type]
+        when :empty_answer_retry then line(format_empty_retry_line(event))
+        when :generation_retrying then line(format_generation_retry_line(event))
+        when :turn_completed, :turn_canceled then @turn_over = true
+        when :hook_notice
+          text = EventRenderer.hook_notice_line(event)
+          @turn_over ? @held << text : line(text)
+        end
+      end
+
+      # Print the notices that came after the turn's end.
+      def flush
+        line(@held.shift) until @held.empty?
+      end
+
+      private
+
+      def line(text)
+        err.puts(text)
+        err.flush
+      end
+
+      def err = @err || $stderr
+
+      # Colour when stderr, where the lines go, is a colour terminal.
+      def color_output?
+        return false unless err.tty?
+        return false if ENV.key?("NO_COLOR")
+
+        ENV.fetch("TERM", "") != "dumb"
+      end
+    end
+  end
+end