samagotchi 0.16.0 → 0.18.0

data/lib/samagotchi/session_metrics.rb

@@ -17,15 +17,24 @@ module Samagotchi
   #
   # Each finished turn leaves a record (status, timings, model, prompt and
   # completion tokens, tool calls, iterations, retries); session totals are
-  # sums over the records, so a worker that stops and wakes again (a new
-  # collector) keeps counting: #session_id= loads the records already saved.
+  # sums over the records, kept as running counters as records are added, so
+  # a worker that stops and wakes again (a new collector) keeps counting:
+  # #session_id= loads the records already saved.
   # Only prompt and completion counts, which every backend reports the same
   # way, are kept.
   #
-  # A snapshot is surfaced via Engine#session_state_snapshot and (optionally)
-  # persisted to a sibling analytics.json next to the session file. The event
-  # trail itself goes to the debug log (LogSubscriber).
+  # A snapshot is surfaced via Engine#session_state_snapshot (the Bridge's
+  # /state, /snapshot, /stats and SSE frames) and persisted to a sibling
+  # analytics.json next to the session file. The live snapshot carries the
+  # totals and only the recent records (the newest finished turn's, plus any
+  # not yet saved, at most LIVE_RECORDS_CAP turns), so it stays the same size
+  # however long the session runs; analytics.json holds every record. The
+  # event trail itself goes to the debug log (LogSubscriber).
   class SessionMetrics
+    # The most turns (with their tool calls) a live snapshot carries: the
+    # unsaved ones of a collector whose saves keep failing stay bounded.
+    LIVE_RECORDS_CAP = 20
+
     # Per-turn transient state, reset on each turn_started.
     TurnState = Struct.new(
       :session_id,
@@ -118,6 +127,11 @@ module Samagotchi
       @turn = nil
       @turn_records = []
       @tool_records = []
+      # How many turn records the last successful save (or the load) holds,
+      # and how many were loaded (a woken collector's live records start empty).
+      @persisted_turns = 0
+      @loaded_turns = 0
+      reset_totals
     end
 
     # /model: the window and prompt profile a turn reported were the old
@@ -213,51 +227,31 @@ module Samagotchi
     # The session totals are sums over the turn records (the ones loaded from
     # disk and this process's), with the running turn's calls, iterations and
     # finished generations counted at once, so /stats agrees mid-turn.
+    # :turn_records / :tool_records are the recent ones only: the newest
+    # finished turn's and any not yet saved (at most LIVE_RECORDS_CAP turns),
+    # with the running turn's finished calls; the full history is the
+    # session's analytics.json.
     # @return [Hash] the current summary snapshot
     def snapshot
-      @mutex.synchronize do
-        records = @turn_records
-        turn = @turn
-        in_flight = turn ? turn.tool_calls_by_id.values : []
-        tools = @tool_records + in_flight
-        {
-          session_id: @session_id,
-          turns: records.size + (turn ? 1 : 0),
-          cancellations: records.count { |record| record[:status] == "canceled" },
-          tokens: {
-            prompt_sum: sum(records, :prompt_tokens_sum) + (turn&.prompt_sum || 0),
-            completion_sum: sum(records, :completion_tokens) + (turn&.completion_sum || 0),
-            source: combined_source(records.map { |record| record[:token_source] } + (turn&.token_sources || []))
-          },
-          context: context_block(records),
-          profile: @profile,
-          profile_source: @profile_source,
-          served_model: @served_model,
-          served_model_for: @served_model_for,
-          tool_calls_total: tools.size,
-          tool_calls_by_tool: tools.map { |tool| tool[:tool].to_s }.reject(&:empty?).tally,
-          tool_errors: @tool_records.count { |tool| tool[:status] == "error" },
-          iterations_total: sum(records, :iterations) + (turn&.iteration_count || 0),
-          gen_latency_ms: (sum(records, :gen_ms) + (turn&.gen_latency_accum || 0)).round,
-          retries: sum(records, :retries) + (turn&.retries || 0),
-          started_at: @started_at,
-          last_activity_at: @last_activity_at,
-          session_duration_ms: elapsed_ms(@session_started_monotonic),
-          turn_records: @turn_records.map(&:dup),
-          tool_records: @tool_records.map(&:dup),
-          active_turn: active_turn_snapshot,
-          active_tools: active_tool_snapshots
-        }
-      end
+      @mutex.synchronize { build_snapshot(:recent) }
+    end
+
+    # The served model a generation last reported and the name asked for
+    # then, without building a snapshot (Engine#served_model).
+    # @return [Hash] :served_model, :served_model_for
+    def served_report
+      @mutex.synchronize { { served_model: @served_model, served_model_for: @served_model_for } }
     end
 
-    # Persist the summary snapshot to a sibling analytics.json in the session
-    # directory. Atomic write; failures are swallowed (analytics must never
-    # break the running session).
+    # Persist the summary snapshot, with every record, to a sibling
+    # analytics.json in the session directory. Atomic write; failures are
+    # swallowed (analytics must never break the running session).
     # @param state_dir [String, nil]
     # @return [Boolean] true on success
     def persist(state_dir: nil)
-      sid = @mutex.synchronize { @session_id }
+      sid, data, turn_count = @mutex.synchronize do
+        [@session_id, build_snapshot(:all).merge(active_turn: nil, active_tools: []), @turn_records.size]
+      end
       return false if sid.nil? || sid.to_s.empty?
 
       # Omitting state_dir lets Session.session_dir fall back to the default
@@ -265,7 +259,8 @@ module Samagotchi
       # File.join.
       FileUtils.mkdir_p(dir = session_dir(sid, state_dir || @state_dir))
       path = File.join(dir, "analytics.json")
-      AtomicFile.write(path, JSON.pretty_generate(snapshot.merge(active_turn: nil, active_tools: [])) + "\n")
+      AtomicFile.write(path, JSON.pretty_generate(data) + "\n")
+      @mutex.synchronize { @persisted_turns = [@persisted_turns, turn_count].max }
       true
     rescue StandardError
       false
@@ -273,6 +268,58 @@ module Samagotchi
 
     private
 
+    # Caller holds the mutex. +records+: :recent (the live snapshot) or :all
+    # (analytics.json).
+    def build_snapshot(records_mode)
+      totals = @totals
+      turn = @turn
+      in_flight = turn ? turn.tool_calls_by_id.values : []
+      {
+        session_id: @session_id,
+        turns: @turn_records.size + (turn ? 1 : 0),
+        cancellations: totals[:cancellations],
+        tokens: {
+          prompt_sum: totals[:prompt_sum] + (turn&.prompt_sum || 0),
+          completion_sum: totals[:completion_sum] + (turn&.completion_sum || 0),
+          source: combined_source(totals[:token_sources] + (turn&.token_sources || []))
+        },
+        context: context_block(@turn_records),
+        profile: @profile,
+        profile_source: @profile_source,
+        served_model: @served_model,
+        served_model_for: @served_model_for,
+        tool_calls_total: @tool_records.size + in_flight.size,
+        tool_calls_by_tool: tally_into(totals[:by_tool].dup, in_flight),
+        tool_errors: totals[:tool_errors],
+        iterations_total: totals[:iterations] + (turn&.iteration_count || 0),
+        gen_latency_ms: (totals[:gen_ms] + (turn&.gen_latency_accum || 0)).round,
+        retries: totals[:retries] + (turn&.retries || 0),
+        started_at: @started_at,
+        last_activity_at: @last_activity_at,
+        session_duration_ms: elapsed_ms(@session_started_monotonic),
+        **records_view(records_mode),
+        active_turn: active_turn_snapshot,
+        active_tools: active_tool_snapshots
+      }
+    end
+
+    # The records a snapshot carries, copied. :all is every record; :recent
+    # the newest turn this collector finished (live before its save lands)
+    # and the unsaved ones (capped), and the tool records of those turns and
+    # of the running one. Records are appended in turn order, so both come
+    # from the tails. Caller holds the mutex.
+    def records_view(mode)
+      return { turn_records: @turn_records.map(&:dup), tool_records: @tool_records.map(&:dup) } if mode == :all
+
+      unsaved = @turn_records.size - @persisted_turns
+      count = unsaved.clamp(@turn_records.size > @loaded_turns ? 1 : 0, LIVE_RECORDS_CAP)
+      turns = @turn_records.last(count)
+      ids = turns.to_set { |record| record[:id] }
+      ids << @turn.id if @turn
+      tools = @tool_records.reverse_each.take_while { |tool| ids.include?(tool[:turn_id]) }.reverse
+      { turn_records: turns.map(&:dup), tool_records: tools.map(&:dup) }
+    end
+
     def begin_turn(event)
       @mutex.synchronize do
         unless @session_id || event[:session_id].to_s.empty?
@@ -328,6 +375,7 @@ module Samagotchi
           record[:cancellation_reason] = reason.to_s unless reason.nil? || reason.to_s.empty?
           record.merge!(turn_token_fields(@turn))
           @turn_records << record
+          count_turn(record)
         end
         @turn = nil
       end
@@ -439,7 +487,7 @@ module Samagotchi
         return unless active
 
         finished_at = now
-        @tool_records << active.slice(
+        record = active.slice(
           :id, :turn_id, :iteration, :call_index, :tool, :started_at
         ).merge(
           status: status.empty? ? "ok" : status,
@@ -447,6 +495,8 @@ module Samagotchi
           # Less a guardrail approval wait (ToolRunner's waited_ms).
           duration_ms: [elapsed_ms(active[:started_monotonic]) - event[:waited_ms].to_i, 0].max
         )
+        @tool_records << record
+        count_tool(record)
       end
     end
 
@@ -548,8 +598,15 @@ module Samagotchi
       prior = JSON.parse(File.read(path))
       return unless prior.is_a?(Hash)
 
-      @turn_records = loaded_records(prior["turn_records"]) + @turn_records
+      loaded_turns = loaded_records(prior["turn_records"])
+      @turn_records = loaded_turns + @turn_records
       @tool_records = loaded_records(prior["tool_records"]) + @tool_records
+      @persisted_turns = @loaded_turns = loaded_turns.size
+      # Once per collector: recount in record order (the tally's key order
+      # stays first-seen).
+      reset_totals
+      @turn_records.each { |record| count_turn(record) }
+      @tool_records.each { |record| count_tool(record) }
       @started_at = earliest_timestamp(prior["started_at"], @started_at)
       @last_activity_at ||= prior["last_activity_at"]
       # The window last seen, until this process's first generation reports.
@@ -579,8 +636,40 @@ module Samagotchi
       }
     end
 
-    def sum(records, key)
-      records.sum { |record| record[key].is_a?(Numeric) ? record[key] : 0 }
+    # The session totals over the finished records, as running counters
+    # (#snapshot adds the running turn). Caller holds the mutex.
+    def reset_totals
+      @totals = { cancellations: 0, prompt_sum: 0, completion_sum: 0, token_sources: [], iterations: 0,
+                  gen_ms: 0, retries: 0, by_tool: {}, tool_errors: 0 }
+    end
+
+    def count_turn(record)
+      totals = @totals
+      totals[:cancellations] += 1 if record[:status] == "canceled"
+      totals[:prompt_sum] += number(record[:prompt_tokens_sum])
+      totals[:completion_sum] += number(record[:completion_tokens])
+      totals[:iterations] += number(record[:iterations])
+      totals[:gen_ms] += number(record[:gen_ms])
+      totals[:retries] += number(record[:retries])
+      source = record[:token_source]
+      totals[:token_sources] |= [source.to_s] unless source.nil?
+    end
+
+    def count_tool(record)
+      @totals[:tool_errors] += 1 if record[:status] == "error"
+      tally_into(@totals[:by_tool], [record])
+    end
+
+    def tally_into(counts, tools)
+      tools.each do |tool|
+        name = tool[:tool].to_s
+        counts[name] = counts.fetch(name, 0) + 1 unless name.empty?
+      end
+      counts
+    end
+
+    def number(value)
+      value.is_a?(Numeric) ? value : 0
     end
 
     # server, estimate, or mixed when both kinds of counts (or a turn that

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

@@ -23,6 +23,15 @@ module Samagotchi
   class SystemPrompt
     AGENT_DESCRIPTION_FILE = "AGENT.md"
 
+    # The model a session runs on, as the prompt names it: the resolved
+    # ref, its host ("name, host:port" or url), the memory overlay key, and
+    # what a llama.cpp server says it serves when that differs (else nil).
+    # fallback_key: the key an alias typed for the model used to key overlays
+    # by (read when +key+ has none, as memory_read does); not shown.
+    ModelIdentity = Data.define(:ref, :host, :key, :served, :fallback_key) do
+      def initialize(ref:, host:, key:, served: nil, fallback_key: nil) = super
+    end
+
     # Always auto-loaded from the system scope unless muted (B-light).
     DEFAULT_SYSTEM_MEMORIES = %w[identity].freeze
 
@@ -34,10 +43,12 @@ module Samagotchi
     # @param tools    [#call] → Tools::Registry
     # @param session  [#call] → Session, nil
     # @param thinking [#call] → Symbol, the effective model's level (Thinking)
+    # @param model    [#call] → ModelIdentity, nil (the section is left out)
     # @param memories [Array<String>] the --memory list
     # @param muted_memory_names [Array<String>] normalized (MutedMemories)
-    def initialize(profile:, tools:, session:, thinking:, memories: [], muted_memory_names: [])
+    def initialize(profile:, tools:, session:, thinking:, model: -> {}, memories: [], muted_memory_names: [])
       @profile_lookup = profile
+      @model_lookup = model
       @tools_lookup = tools
       @session_lookup = session
       @thinking_lookup = thinking
@@ -223,7 +234,7 @@ module Samagotchi
         "Project memories:\n#{project_index}",
         "System memories:\n#{system_index}"
       ].join("\n\n")
-      [thinking_token + base, rg_guidance, project_description, project_location, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
+      [thinking_token + base, rg_guidance, project_description, project_location, current_model, current_session, memory_sections, system_identity_section, explicit_memory_section].compact.join("\n")
     end
 
     # B-light: auto-preload the built-in identity memory.
@@ -235,7 +246,7 @@ module Samagotchi
       DEFAULT_SYSTEM_MEMORIES.each do |name|
         next if memory_muted?(name)
 
-        body = Tools::MemoryRead.call(name, scope: "system")
+        body = Tools::MemoryRead.call(name, scope: "system", **overlay_keys)
         next if body.start_with?("Error:")
         next if body.strip.empty?
 
@@ -248,6 +259,17 @@ module Samagotchi
 
     # ── Memory helpers ─────────────────────────────────────────────────────────
 
+    # The session model's overlay keys, so the prompt's own memory bodies
+    # (identity, preloads) get `<name>.<key>.md` as memory_read gives it.
+    def overlay_keys
+      model = @model_lookup.call
+      return {} unless model&.key
+
+      { model_key: model.key, fallback_model_key: model.fallback_key }
+    rescue StandardError
+      {}
+    end
+
     # The scope's index text without the muted memories' lines.
     def read_memory_index(scope)
       BundleNeeds.annotate_index(MutedMemories.filter_index(Tools::MemoryRead.call("", scope: scope), @muted_memory_names), scope)
@@ -297,7 +319,7 @@ module Samagotchi
         names = raw.split(",").map(&:strip).reject(&:empty?)
         names.each do |name|
           scope, actual_name = split_memory_scope(name)
-          body = Tools::MemoryRead.call(actual_name, scope: scope)
+          body = Tools::MemoryRead.call(actual_name, scope: scope, **overlay_keys)
           if body.start_with?("Error:")
             source = Array(@config_memories).include?(raw) ? "memory '#{name}' (from config memories:)" : "--memory '#{name}'"
             Log.warn(:memory, "preload_failed", echo: "Warning: #{source} could not be loaded (#{body})", memory: name)
@@ -359,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
@@ -378,6 +400,25 @@ module Samagotchi
       path
     end
 
+    # The model this session runs on. A model guesses its name from
+    # training (a fine-tune often knows only its base model's), so the line
+    # says to answer from here. It depends only on the effective model, and
+    # the prompt is rebuilt only on a switch (#reset!): no per-turn churn.
+    def current_model
+      model = @model_lookup.call
+      return nil unless model && !model.ref.to_s.empty?
+
+      details = [model.host, model.key && "model key #{model.key}", model.served && "the server says it serves #{model.served}"]
+      details = details.compact.reject(&:empty?)
+      where = details.empty? ? "" : " (#{details.join("; ")})"
+      "Model: this session runs on #{model.ref}#{where}.\n" \
+        "Asked which model you are, answer with this line, not from training: a fine-tuned model often knows only " \
+        "its base model's name, but this session runs what is named here; it changes only with /model. " \
+        "Guidance for this model only goes in memory overlays: memory_write current_model_only: true."
+    rescue StandardError
+      nil
+    end
+
     # Fixed for the session's lifetime, so it doesn't churn the prompt cache.
     # Omitted until a session is attached (run_turn / TerminalUI set it). A
     # delegated session (parent_id set) is told who reads its reply.

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -310,7 +310,13 @@ module Samagotchi
         return detach("Detached; the session keeps running. Re-attach with: chi --attach #{@client.session_id}") if line.nil?
 
         text = line.strip
-        return answer_question(text) if @question
+        if @question
+          # /detach leaves the question open, as Ctrl-D does; any other
+          # line (/exit too) is read as the answer.
+          return submit(nil) if command_registry.lookup_local(text)&.id == :detach
+
+          return answer_question(text)
+        end
 
         # The terminal's own commands (SessionCommands registers them, the
         # REPL reads the same words). Before the continue offer: the
@@ -336,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
@@ -449,7 +458,12 @@ module Samagotchi
       # too, so nothing waits here.
       def send_command(line)
         reply = @client.post_command(line: line, client_id: @client_id)
-        return if reply.status == 202
+        if reply.status == 202
+          # Input from a pipe ends once its output is in (#command_ran).
+          command_id = reply.json&.fetch("command_id", nil)
+          @open_ids << command_id if command_id && @wait_at_eof
+          return
+        end
         return @screen.commit(stale_worker("run commands")) if reply.status == 404
         return @screen.commit("could not run the command (#{LATE})") if too_late?(reply)
 
@@ -473,6 +487,7 @@ module Samagotchi
       end
 
       def command_ran(event)
+        @open_ids.delete(event[:command_id])
         @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime] || event[:card]
         output = event[:output].to_s
         if output.empty?
@@ -510,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"
@@ -518,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)))
@@ -680,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
@@ -693,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
@@ -881,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])
@@ -939,7 +964,15 @@ module Samagotchi
         return if text.empty?
 
         @screen.commit("#{paint(PROMPT, 92)}#{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/event_renderer.rb

@@ -63,7 +63,8 @@ module Samagotchi
         when :generation_chunk
           @view.generation_feedback_chunk(event)
         when :tool_call_started
-          @tool_started_at[tool_call_key(event)] = @clock.call
+          # A joined running call (a snapshot's replay) started elapsed_ms ago.
+          @tool_started_at[tool_call_key(event)] = @clock.call - (event[:elapsed_ms].to_f / 1000)
           @view.tool_call_feedback_started(event)
         when :tool_call_completed
           @view.clear_generation_retry

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?