samagotchi 0.19.0 → 0.21.0

data/lib/samagotchi/llm/openai_chat.rb

@@ -35,10 +35,12 @@ module Samagotchi
     # ([] when none), usage (never nil) and the finish reason.
     # +model+ is the model the server says answered (the body's `model`),
     # which can differ from the one asked for; nil when it says nothing.
+    # +provider+ is the provider that served it (the body's `provider`,
+    # OpenRouter's routing name); nil when the server says nothing.
     # +cut+ is set on the empty response the chat loop makes for a
     # generation a plugin cut (stop_generation): {by:, reason:}.
-    ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :cut) do
-      def initialize(model: nil, cut: nil, **fields) = super
+    ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut) do
+      def initialize(model: nil, provider: nil, cut: nil, **fields) = super
     end
 
     # The OpenAI Chat Completions API (llama.cpp's /v1, and any compatible
@@ -248,7 +250,8 @@ module Samagotchi
         ChatResponse.new(text: OpenAIChat.drop_leading_newlines(message["content"].to_s),
                          reasoning: (message["reasoning_content"] || message["reasoning"]).to_s,
                          tool_calls: calls, usage: Usage.from_payload(body) || Usage.none,
-                         finish_reason: body.dig("choices", 0, "finish_reason"), model: served_model(body))
+                         finish_reason: body.dig("choices", 0, "finish_reason"), model: served_model(body),
+                         provider: self.class.served_provider(body))
       end
 
       # Workaround for Splash 1.0.2/1.1.0, which keeps the "\n\n" the model
@@ -265,6 +268,15 @@ module Samagotchi
 
       def served_model(payload) = self.class.served_model(payload)
 
+      # OpenRouter names the provider that served a request (Baseten,
+      # Fireworks, …) in the body's `provider`; other servers send none.
+      def self.served_provider(payload)
+        provider = payload.is_a?(Hash) ? payload["provider"] : nil
+        provider.is_a?(String) && !provider.strip.empty? ? provider : nil
+      end
+
+      def served_provider(payload) = self.class.served_provider(payload)
+
       # The parsed payload of a `data:` line; nil for blank lines, comments
       # and [DONE]. Error events raise their ProviderError.
       # A 200 whose body is a plain JSON error instead of a stream (OpenRouter
@@ -352,7 +364,7 @@ module Samagotchi
       def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       # Streamed deltas put together: text, reasoning, tool calls by index,
-      # the finish reason, the usage chunk and the served model.
+      # the finish reason, the usage chunk, the served model and provider.
       class Assembly
         # The chunk carries part of a tool call.
         def self.tool_call_delta?(payload)
@@ -367,12 +379,14 @@ module Samagotchi
           @finish_reason = nil
           @usage = nil
           @model = nil
+          @provider = nil
         end
 
         # @return [Array(String, String)] this chunk's content and reasoning
         def add(payload)
           @usage = Usage.from_payload(payload) || @usage if payload.key?("usage")
           @model = OpenAIChat.served_model(payload) || @model
+          @provider = OpenAIChat.served_provider(payload) || @provider
           choice = payload["choices"].is_a?(Array) ? payload["choices"].first : nil
           return ["", ""] unless choice.is_a?(Hash)
 
@@ -392,7 +406,7 @@ module Samagotchi
             ToolCall.new(id: call[:id], name: call[:name].to_s, arguments: OpenAIChat.parse_arguments(call[:arguments]))
           end
           ChatResponse.new(text: @text, reasoning: @reasoning, tool_calls: calls, usage: @usage || Usage.none,
-                           finish_reason: @finish_reason, model: @model)
+                           finish_reason: @finish_reason, model: @model, provider: @provider)
         end
 
         private

data/lib/samagotchi/llm/usage.rb

@@ -12,7 +12,7 @@ module Samagotchi
         counts = TokenUsage.from_payload(payload)
         return nil unless counts
 
-        new(prompt_tokens: counts[:prompt_tokens].to_i, completion_tokens: counts[:completion_tokens].to_i,
+        new(prompt_tokens: counts.prompt_tokens.to_i, completion_tokens: counts.completion_tokens.to_i,
             source: :server)
       end
 

data/lib/samagotchi/log_subscriber.rb

@@ -82,7 +82,8 @@ module Samagotchi
     end
 
     def on_turn_canceled(event)
-      log(:info, :turn_canceled, ms: since(@turn_started_at), reason: event[:cancellation_reason], **origin(event))
+      log(:info, :turn_canceled, ms: since(@turn_started_at), reason: event[:cancellation_reason], by: event[:cancelled_by],
+                                 **origin(event))
     end
 
     def on_turn_failed(event)
@@ -100,7 +101,8 @@ module Samagotchi
     def on_generation_completed(event)
       ms = since(@generation_started_at.delete(event[:iteration]))
       log(:info, :generation_completed, iteration: event[:iteration], ms: ms,
-                                        served_model: event[:served_model], requested_model: event[:requested_model],
+                                        served_model: event[:served_model], provider: event[:served_provider],
+                                        requested_model: event[:requested_model],
                                         content_length: event[:content_length],
                                         thinking_chars: event[:thinking_chars], finish_reason: event[:finish_reason],
                                         stopped_by: event[:stopped_by])

data/lib/samagotchi/memory_bundle/builder.rb

@@ -41,7 +41,7 @@ module Samagotchi
       end
 
       def run
-        target_dir = resolve_target_dir(@scope)
+        target_dir = MemoryPaths.scope_dir(@scope) or raise BuildError, "invalid scope: #{@scope}"
         resolved_name = @name || default_name(@scope)
         resolved_version = @version || DEFAULT_VERSION
 
@@ -333,10 +333,6 @@ module Samagotchi
         base
       end
 
-      def resolve_target_dir(scope)
-        MemoryPaths.scope_dir(scope) or raise BuildError, "invalid scope: #{scope}"
-      end
-
       def resolve_out_path(out_arg, default_name)
         if out_arg.nil? || out_arg.empty?
           # Default: <name>.zip in Dir.pwd

data/lib/samagotchi/memory_bundle/installer.rb

@@ -51,6 +51,22 @@ module Samagotchi
       # none moved).
       def trash_dir = @trash.dir
 
+      # The normalized source dir, kept alive past #run when an upgrade has
+      # conflicts (the agent step reads the incoming files); nil once cleaned.
+      attr_reader :source_dir
+
+      # Removes the normalized source dir an owned source (git/zip/tar) was
+      # extracted to. #run defers this when it found conflicts, so the
+      # conflict prompt and resolve_conflicts can still read the incoming
+      # files; the caller runs it once the agent step is done. Idempotent.
+      def cleanup_source!
+        return unless @defer_cleanup && @normalized_dir
+
+        SourceNormalizer.cleanup(@normalized_dir)
+        @normalized_dir = nil
+        @defer_cleanup = false
+      end
+
       def run
         normalized_dir = nil
         source_owned = false
@@ -59,6 +75,7 @@ module Samagotchi
         begin
           normalized_dir, source_owned, source_commit = SourceNormalizer.normalize(@source)
           @bundle_dir = normalized_dir
+          @normalized_dir = normalized_dir
           manifest = Manifest.read(dir: normalized_dir)
         rescue SourceNormalizer::UnknownSourceError => e
           raise InstallError, "Source normalization failed: #{e.message}"
@@ -73,7 +90,7 @@ module Samagotchi
         # Determine target scope (CLI wins over manifest).
         cli_scope = @scope.to_s.strip.empty? ? nil : @scope
         target_scope = cli_scope || manifest&.scope || "system"
-        target_dir = resolve_target_dir(target_scope)
+        target_dir = MemoryPaths.scope_dir(target_scope) or raise InstallError, "invalid scope: #{target_scope}"
         FileUtils.mkdir_p(target_dir)
 
         # Copy .md files and update index for each.
@@ -199,12 +216,15 @@ module Samagotchi
             end
 
             FileUtils.mkdir_p(hooks_target)
+            unchanged = File.exist?(dest) && FileUtils.identical?(src, dest)
             FileUtils.cp(src, dest)
-            if @upgrade && existing_provenance
-              @results[basename] = { status: "updated" }
-            else
-              @results[basename] = { status: "installed" }
-            end
+            @results[basename] = if unchanged
+                                   { status: "skipped", reason: "already up to date" }
+                                 elsif @upgrade && existing_provenance
+                                   { status: "updated" }
+                                 else
+                                   { status: "installed" }
+                                 end
             hooks_files_for_provenance[basename] = dest
           end
         else
@@ -406,7 +426,17 @@ module Samagotchi
 
         [normalized_dir, manifest]
       ensure
-        SourceNormalizer.cleanup(normalized_dir) if source_owned
+        # An owned source (git/zip/tar) is cleaned up here, unless an upgrade
+        # kept conflicts: the agent step still needs the incoming files, so
+        # the caller runs #cleanup_source! when it is done.
+        if source_owned
+          if @conflicts.any? && !@dry_run
+            @defer_cleanup = true
+          else
+            SourceNormalizer.cleanup(normalized_dir)
+            @normalized_dir = nil
+          end
+        end
       end
 
       def summary
@@ -541,11 +571,18 @@ module Samagotchi
           return nil
         end
 
+        dest = File.join(provenance.plugin_dir, plugin[:file])
+        unchanged = File.file?(dest) && FileUtils.identical?(src, dest)
         FileUtils.rm_rf(provenance.plugin_dir)
         FileUtils.mkdir_p(provenance.plugin_dir)
-        dest = File.join(provenance.plugin_dir, plugin[:file])
         FileUtils.cp(src, dest)
-        @results[plugin[:file]] = { status: @upgrade && provenance.read ? "updated" : "installed" }
+        @results[plugin[:file]] = if unchanged
+                                   { status: "skipped", reason: "already up to date" }
+                                 elsif @upgrade && provenance.read
+                                   { status: "updated" }
+                                 else
+                                   { status: "installed" }
+                                 end
         expected = manifest.checksum_for_plugin
         actual = Digest::SHA256.hexdigest(File.binread(dest))
         if @strict && expected && actual != expected
@@ -598,10 +635,6 @@ module Samagotchi
           @warnings << "index.md: line for #{entry_name} not updated (#{e.message})"
         end
       end
-
-      def resolve_target_dir(scope)
-        MemoryPaths.scope_dir(scope) or raise InstallError, "invalid scope: #{scope}"
-      end
     end
   end
 end

data/lib/samagotchi/memory_bundle/shipped_update.rb

@@ -9,6 +9,7 @@ require_relative "provenance"
 require_relative "source"
 require_relative "status"
 require_relative "system_bundle"
+require_relative "../memory_paths"
 require_relative "../version"
 
 module Samagotchi
@@ -112,6 +113,7 @@ module Samagotchi
           return skip(row, "needs chi #{manifest.requires_chi}", keep_to: true)
         end
         return skip(row, "project scope: chi bundle upgrade #{ship.source} in the project") if row.scope == "project"
+        return skip(row, "unknown scope #{row.scope}: upgrade chi or reinstall") unless MemoryPaths.scope_dir(row.scope)
 
         row.kept = conflicts(row, data)
         row.replaced = edited_executables(name, data)
@@ -147,7 +149,7 @@ module Samagotchi
       # version (a same-name file it didn't install is skipped, not merged).
       def conflicts(row, data)
         provenance = Provenance.new(name: row.name)
-        target_dir = Status.resolve_target_dir(row.scope)
+        target_dir = MemoryPaths.scope_dir!(row.scope)
         return [] unless data[:files].is_a?(Hash)
 
         owned = data[:files].keys.map(&:to_s)

data/lib/samagotchi/memory_bundle/status.rb

@@ -11,6 +11,9 @@ require_relative "../model_overlay"
 module Samagotchi
   module MemoryBundle
     module Status
+      # A scope this chi can't resolve (a newer chi's, a hand edit) isn't
+      # guessed: scope_error says so, target_dir is nil and each file is
+      # unchecked (no disk reads, nothing counted as missing).
       def self.bundle_status(name, scope_override: nil)
         provenance = Provenance.new(name: name)
         data = provenance.read
@@ -18,11 +21,13 @@ module Samagotchi
 
         raw_scope = scope_override || data[:scope]&.to_s
         scope = (raw_scope.nil? || raw_scope.strip.empty?) ? "system" : raw_scope
-        target_dir = resolve_target_dir(scope)
+        target_dir = MemoryPaths.scope_dir(scope)
         files = data[:files] || {}
         details = {}
         files.each do |file_key, meta|
           file_key_str = file_key.to_s
+          next details[file_key_str] = unchecked_file(meta) unless target_dir
+
           target_path = File.join(target_dir, file_key_str)
           base_path = provenance.base_path(file_key_str)
           stored_checksum = meta[:checksum] || meta["checksum"]
@@ -46,7 +51,8 @@ module Samagotchi
             base_path: base_path
           }
         end
-        { provenance: data, scope: scope, target_dir: target_dir, files: details, plugin: plugin_status(provenance, data),
+        { provenance: data, scope: scope, scope_error: target_dir ? nil : "unknown scope: #{scope}",
+          target_dir: target_dir, files: details, plugin: plugin_status(provenance, data),
           hooks_requires_failure: hooks_requires_failure(data), needs: needs_status(data) }
       end
 
@@ -91,9 +97,11 @@ module Samagotchi
           requires_failure: Manifest.requires_chi_failure(data[:requires_chi], Samagotchi::VERSION) }
       end
 
-      def self.resolve_target_dir(scope)
-        MemoryPaths.scope_dir(scope) || MemoryPaths.system_dir
+      def self.unchecked_file(meta)
+        { conflict: meta.is_a?(Hash) && meta[:conflict] == true, stored_checksum: meta.is_a?(Hash) ? meta[:checksum] || meta["checksum"] : nil,
+          unchecked: true, modified: false, missing: false, index_present: nil, overlay: false }
       end
+      private_class_method :unchecked_file
 
       # Index lines name the entry without ".md" (Installer#update_target_index,
       # memory_write); a legacy "name.md" line counts too.

data/lib/samagotchi/memory_bundle/uninstaller.rb

@@ -39,7 +39,7 @@ module Samagotchi
         cli_scope = @scope.to_s.strip.empty? ? nil : @scope
         raw = cli_scope || data[:scope]&.to_s
         target_scope = (raw.nil? || raw.strip.empty?) ? "system" : raw
-        target_dir = resolve_target_dir(target_scope)
+        target_dir = MemoryPaths.scope_dir(target_scope) or raise UninstallError, "invalid scope: #{target_scope}"
 
         files = data[:files] || {}
         hooks = data[:hooks] || {}
@@ -129,10 +129,6 @@ module Samagotchi
       rescue StandardError => e
         @warnings << "index.md: line for #{file_key.delete_suffix(".md")} not updated (#{e.message})"
       end
-
-      def resolve_target_dir(scope)
-        MemoryPaths.scope_dir(scope) or raise UninstallError, "invalid scope: #{scope}"
-      end
     end
   end
 end

data/lib/samagotchi/memory_paths.rb

@@ -112,6 +112,12 @@ module Samagotchi
       end
     end
 
+    # scope_dir, or ArgumentError ("invalid scope: team") for a scope it
+    # doesn't know: for a caller that must not guess a folder.
+    def scope_dir!(scope, env: ENV, cwd: Dir.pwd)
+      scope_dir(scope, env: env, cwd: cwd) or raise ArgumentError, "invalid scope: #{scope}"
+    end
+
     def bundles_dir(env: ENV)
       File.join(system_dir(env: env), ".bundles")
     end

data/lib/samagotchi/self_report.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "json"
+require "net/http"
+require "uri"
 require_relative "version"
 require_relative "config"
 require_relative "context_window"
@@ -11,6 +13,8 @@ require_relative "model_overlay"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
+require_relative "llm/http"
+require_relative "llm/api_key"
 require_relative "tools/memory"
 require_relative "hooks/loader"
 require_relative "memory_bundle/provenance"
@@ -194,7 +198,9 @@ module Samagotchi
 
     # 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.
+    # GET with the probe's short timeouts; a remote host isn't asked. A local
+    # chat host (api: openai) has no /props, so it gets a GET <base>/models
+    # with the same timeouts: up/down and the ids it serves.
     def served_model_for(model, env)
       registry = HostRegistry.new(env: env)
       target = registry.resolve(model)
@@ -202,7 +208,7 @@ module Samagotchi
       bare = target.bare_model
       return "-" unless entry
       return "reported per turn (remote host)" if entry.remote?
-      return NO_PROPS if entry.chat?
+      return chat_served_model_for(entry, bare, env) if entry.chat?
 
       client = registry.client_for(entry)
       props = client.server_props(model: bare)
@@ -217,6 +223,36 @@ module Samagotchi
       "unknown (#{e.class})"
     end
 
+    # A local chat host's reachability: one GET <base>/models with the
+    # native probe's short timeouts (Client's /props probe), no retry. Up
+    # with the ids it serves, down when it doesn't answer.
+    def chat_served_model_for(entry, bare, env)
+      uri = URI("#{entry.openai_base_url}/models")
+      request = Net::HTTP::Get.new(uri)
+      http = LLM::HTTP.new(label: entry.name, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
+                           read_timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT,
+                           retry_policy: LLM::HTTP::RetryPolicy.none,
+                           api_key: LLM::ApiKey.for(entry.api_key_env, host: entry.host, env: env))
+      response = http.fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "models" })
+      return "down (HTTP #{response.code})" unless response.code.to_s == "200"
+
+      ids = chat_model_ids(response.body)
+      return "up (no models listed)" if ids.empty?
+
+      note = ids.any? { |id| id.casecmp?(bare.to_s) } ? "" : " (not #{bare})"
+      "up: #{ids.join(", ")}#{note}"
+    rescue StandardError
+      "down (the server didn't answer; is it running?)"
+    end
+
+    def chat_model_ids(body)
+      parsed = JSON.parse(body.to_s)
+      data = parsed.is_a?(Hash) ? parsed["data"] : parsed
+      Array(data).filter_map { |raw| raw.is_a?(Hash) ? (raw["id"] || raw[:id]).to_s : raw.to_s }.reject(&:empty?)
+    rescue JSON::ParserError
+      []
+    end
+
     # Offline, so no /props probe: where nothing is configured, a native
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)

data/lib/samagotchi/session.rb

@@ -5,6 +5,7 @@ require "json"
 require "securerandom"
 require "time"
 require_relative "atomic_file"
+require_relative "context_note"
 
 require_relative "paths"
 require_relative "project_scope"
@@ -413,27 +414,55 @@ module Samagotchi
 
     # Derive and cache the first user-message preview in the session record.
     # Returns true if the cached value was set or updated.
+    # A session with only context notes so far previews by its first note
+    # ("note: …"), until a message is typed.
     def compute_first_preview!
-      return false if @first_preview && !@first_preview.empty?
+      from_note = note_preview
+      return false if @first_preview && !@first_preview.empty? && @first_preview != from_note
 
       first_user = @messages.find { |m| m[:role].to_s == "user" || m["role"].to_s == "user" }
-      return false unless first_user
-
-      preview = self.class.preview_of(first_user[:content] || first_user["content"])
-      return false if preview.empty?
+      preview = first_user ? self.class.preview_of(first_user[:content] || first_user["content"]) : from_note.to_s
+      return false if preview.empty? || preview == @first_preview
 
       @first_preview = preview
       true
     end
 
+    # The web's annotation labels (annotations.js sourceLabel), each on its
+    # own line above a quote.
+    QUOTE_LABEL_RE = /\AFrom (?:your thinking|your earlier step|the .{1,80} call|my earlier message):\z/
+
     # A prompt as a one-line preview: whitespace collapsed, cut at 80 chars.
+    # A quoted or annotated message previews by what was typed under the
+    # quote; a quote alone by its words, without the "> " markers or label.
     def self.preview_of(text)
-      norm = text.to_s.gsub(/\s+/, " ").strip
+      norm = preview_words(text.to_s).gsub(/\s+/, " ").strip
       norm.length > 80 ? "#{norm[0, 80]}…" : norm
     end
 
+    def self.preview_words(text)
+      lines = text.lines.map(&:strip)
+      quoted = lines.select { |line| line.start_with?(">") }
+      return text if quoted.empty?
+
+      own = lines.reject { |line| line.start_with?(">") || QUOTE_LABEL_RE.match?(line) }.join("\n")
+      return own unless own.strip.empty?
+
+      quoted.map { |line| line.sub(/\A(?:>[ \t]?)+/, "") }.join("\n")
+    end
+    private_class_method :preview_words
+
     private
 
+    # @return [String, nil] the first context note as a preview
+    def note_preview
+      note = @messages.find { |m| ContextNote.note?(m) }
+      return nil unless note
+
+      text = self.class.preview_of(ContextNote.text_of(note))
+      text.empty? ? nil : self.class.preview_of("note: #{text}")
+    end
+
     def stringify_message_keys(hash)
       hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
     end

data/lib/samagotchi/session_commands.rb

@@ -234,6 +234,9 @@ module Samagotchi
       rules = @engine.guardrail_rules
       approvals = @engine.guardrail_approvals.entries
       lines = ["guardrails: #{rules.enabled? ? "on" : "off (guardrails.enabled: false; denies still apply)"}"]
+      lines << if rules.mode == "strict" then "mode: strict (every rule votes)"
+               else "mode: auto (rules marked strict only don't vote; guardrails.mode: strict in config.yml for those)"
+               end
       name = @engine.guardrail_model_name
       key = @engine.model_key
       lines << "model: #{name || "none"} — #{Guardrails::ModelSize.describe(name, key)}"
@@ -253,9 +256,14 @@ module Samagotchi
           ("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)
+          ("touches #{rule.touches}" if rule.touches),
+          ("rm #{rule.rm}" if rule.rm),
+          ("models #{rule.models.join(",")}" if rule.models),
+          ("modes #{rule.modes.join(",")}" if rule.modes),
+          ("skip_read_only" if rule.skip_read_only)
         ].compact.join(", ")
         off = "disabled (guardrails.disable) — " if rules.disabled?(rule)
+        off ||= "(#{rule.modes.join(", ")} only) — " unless rule.for_mode?(rules.mode)
         off ||= "off for this model — " unless rule.for_model?(name, key)
         lines << "  #{idx + 1}. #{rule.id}: #{off}#{rule.verdict} (#{match}) — #{rule.reason} [#{rule.source}]"
       end
@@ -277,7 +285,10 @@ module Samagotchi
 
     def approval_line(entry)
       what = entry["key"] ? entry["key"].tr("\n", " ") : "any call rule #{entry["rule"]} asks about"
-      where = entry["scope"] == "session" ? "session #{entry["session_id"].to_s[0, 8]}" : "in #{entry["repo_root"]}"
+      where = if entry["scope"] == "session" then "session #{entry["session_id"].to_s[0, 8]}"
+              elsif entry["repo"] then "in repo #{entry["repo"]}"
+              else "in #{entry["repo_root"]}"
+              end
       rule = entry["rule"] ? " (rule #{entry["rule"]}, #{entry["source"]})" : ""
       "#{entry["scope"]}: #{what} — #{where}#{rule}, #{entry["created_at"]}"
     end

data/lib/samagotchi/session_manager.rb

@@ -24,6 +24,7 @@ require_relative "installed_gem"
 require_relative "installed_versions"
 require_relative "recap_store"
 require_relative "archive_store"
+require_relative "continue_offer"
 require_relative "image_store"
 require_relative "plugin_session_state"
 require_relative "terminal_ui"
@@ -105,6 +106,10 @@ module Samagotchi
         case @reason
         when :scratch then "a scratch session is deleted when you leave; nothing to archive"
         when :busy_child then "its delegate #{@busy_id[0, 8]} is running a turn; wait for it or stop it first"
+        when :queued then "a prompt is queued, which a resume would run; let it run first"
+        when :queued_child then "its delegate #{@busy_id[0, 8]} has a prompt queued, which a resume would run; let it run first"
+        when :offer then "the step-limit question waits for an answer; answer Continue or Stop first"
+        when :offer_child then "its delegate #{@busy_id[0, 8]} waits for an answer to its step-limit question; answer it first"
         else "a turn is running; wait for it or cancel it first"
         end
       end
@@ -309,8 +314,9 @@ module Samagotchi
     #   discarded: empty sessions their stopping worker deleted
     # @raise [ArgumentError] unknown id (Session::AmbiguousId for a prefix of several)
     # @raise [OwnedByTUI] a chi REPL owns it or one of its children
-    # @raise [ArchiveRefused] a turn runs in it or in a child, or it is a
-    #   scratch session
+    # @raise [ArchiveRefused] a turn runs in it or in a child, a prompt is
+    #   queued in one (a later resume would run it), a live one offers to
+    #   continue past the step limit, or it is a scratch session
     def self.archive_session(id_or_prefix, state_dir: nil, wait: 5)
       sd = state_dir || Session.default_state_dir
       id = archive_target(id_or_prefix, sd)
@@ -319,13 +325,8 @@ module Samagotchi
       tree = [id, *descendant_ids(id, sd)]
       owners = tree.to_h { |sid| [sid, session_owner(sid, state_dir: sd)] }
       tree.each do |sid|
-        owner = owners[sid]
-        next unless owner
-
-        raise OwnedByTUI, sid if owner.tui?
-        next unless Session.load(sid, state_dir: sd).status == Session::STATUS_RUNNING
-
-        raise ArchiveRefused.new(id, sid == id ? :busy : :busy_child, busy_id: sid)
+        refusal = archive_refusal(sid, owners[sid], sd)
+        raise ArchiveRefused.new(id, sid == id ? refusal : :"#{refusal}_child", busy_id: sid) if refusal
       end
 
       stopped = tree.select { |sid| owners[sid] }
@@ -334,6 +335,22 @@ module Samagotchi
       { id: id, archived: archived, stopped: stopped, discarded: discarded }
     end
 
+    # What keeps +sid+ (in an archive's tree) from being archived: :busy (a
+    # turn runs), :queued (input/ holds a prompt, which outlives the stop and
+    # runs on a resume, live worker or not), :offer (a live worker's continue
+    # offer, which the stop would drop), or nil.
+    # @raise [OwnedByTUI] a chi REPL owns it
+    def self.archive_refusal(sid, owner, state_dir)
+      raise OwnedByTUI, sid if owner&.tui?
+
+      session = owner && Session.load(sid, state_dir: state_dir)
+      return :busy if session&.status == Session::STATUS_RUNNING
+      return :queued unless SessionInbox.find_new_input_files(Session.session_dir(sid, state_dir: state_dir)).empty?
+
+      :offer if session&.waiting_question(live: true)&.dig(:kind) == ContinueOffer::KIND
+    end
+    private_class_method :archive_refusal
+
     # Unarchive a session and its delegated children.
     # @return [Hash] {id:, unarchived: [ids that were archived]}
     # @raise [ArgumentError] unknown id