samagotchi 0.102.0 → 0.104.0

data/lib/samagotchi/kernel_loop.rb

@@ -30,6 +30,7 @@ require_relative "tool_ids"
 require_relative "llm_context_view"
 require_relative "llm_context_apply"
 require_relative "llm_context_forget"
+require_relative "working_set"
 require_relative "llm_context_notice"
 require_relative "answer_display"
 require_relative "llm/model_result"
@@ -146,6 +147,11 @@ module Samagotchi
     #   write; the Engine's own (it hands it to a kernel it was given).
     attr_accessor :reminder_store
 
+    # @return [Float, nil] the last counted request's chars per token
+    #   (ContextStatus#counted_chars_per_token), for the next turn's first
+    #   estimate (no dip at a turn's start)
+    attr_accessor :counted_chars_per_token
+
     # @return [ModelProfile] the active prompt profile
     attr_reader :profile
 
@@ -178,6 +184,10 @@ module Samagotchi
     # a plugin tool's row refs resolve their files against (ToolRunner,
     # RowRefs); the Engine sets it. nil: the process's own (Dir.pwd).
     attr_accessor :session_cwd
+    # The session's working-set pins (a callable → Array<WorkingSetPin>),
+    # which forget_outputs refuses (LLMContextForget); the Engine sets it.
+    # nil: none.
+    attr_accessor :working_set_pins
     # The session's folder (a callable → String or nil), where ToolRunner
     # saves a cut output whole (ToolOutputFiles); the Engine sets it. nil:
     # none (a bare kernel), the cut says the output wasn't saved.
@@ -304,7 +314,8 @@ module Samagotchi
 
     def start_turn(messages, on_stream_event:, cancel_controller:, pending_input:, cap:, reasoning_since: nil)
       conversation = prepare_conversation(messages, keep_thought_from: ReasoningHistory.run_start(messages, reasoning_since))
-      context = ContextStatus.new(conversation: conversation, llm_context: @turn_settings.llm_context)
+      context = ContextStatus.new(conversation: conversation, llm_context: @turn_settings.llm_context,
+                                  counted_chars_per_token: @counted_chars_per_token)
       emit = ->(event) { emit_stream_event(on_stream_event, event) }
       @llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: context, emit: emit)
       Turn.new(
@@ -604,6 +615,7 @@ module Samagotchi
       response = generation.response.to_s
       turn.context.generation_done(generation.usage, prompt_chars: request.prompt.length, image_tokens: request.image_tokens,
                                                      window: request.window)
+      @counted_chars_per_token = turn.context.counted_chars_per_token || @counted_chars_per_token
       emit(turn, type: :generation_completed, iteration: turn.iteration, content_length: response.length,
                  thinking_chars: thinking_chars(response, generation.streamed_thinking),
                  served_model: generation.served_model, requested_model: turn.model_name,
@@ -945,8 +957,15 @@ module Samagotchi
       end
 
       apply = -> { apply_llm_context!(turn.conversation, llm_context, context: turn.context, emit: turn.emit) }
-      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply)
+      LLMContextForget.call(turn, call, llm_context: llm_context, apply: apply, pinned: method(:pinned_ids))
+    end
+
+    # The ids of +conversation+'s outputs the session's pins hold.
+    def pinned_ids(conversation)
+      pins = Array(@working_set_pins&.call)
+      WorkingSet.pinned_ids(conversation, pins: pins, cwd: @session_cwd&.call)
     end
+    private :pinned_ids
 
     # Before each request of both loops (+moment+ :request; the warm-up
     # too, on its own copy, as the next turn's first request) and at the

data/lib/samagotchi/launch_mode.rb

@@ -11,6 +11,18 @@ module Samagotchi
     # reach the worker: a /model command, and no_interrupt on each posted
     # turn; --memory and --mute are session fields the worker reads.)
     REPL_ONLY = { verbose: "--verbose" }.freeze
+    # What an attached run can't be combined with (the worker runs its turns).
+    ATTACHED_CONFLICTS = { non_interactive: "--non-interactive", verbose: "--verbose" }.freeze
+    # Opening a `chi scratch` session a killed REPL left behind would turn it
+    # into a kept one.
+    SCRATCH_LEFTOVER = "that's a leftover scratch session; it is deleted at the next sweep (chi sessions clean)"
+    # A worker spawned or resumed for an attach whose Bridge never came (%s:
+    # the session id).
+    BRIDGE_LATE = "the worker for session %s did not start its Bridge in time"
+    # An attach (or a resume) that found the session's worker leaving, its
+    # Bridge closed and its recap on leave still being written: it waits for
+    # the worker to let go (OwnerLock.await_release), then starts a new one.
+    RECAP_WAIT = "(waiting for the session to finish its recap…)"
 
     module_function
 
@@ -30,5 +42,19 @@ module Samagotchi
 
       [:attached, nil]
     end
+
+    # Why an attached run's flags don't go together, or nil when they do.
+    # @param options [Hash] bin/chi's parsed options
+    # @return [String, nil]
+    def attached_conflict(options)
+      conflict = ATTACHED_CONFLICTS.find { |key, _flag| options[key] }
+      if options[:attach] && options[:shared]
+        "use either --attach ID or --shared"
+      elsif options[:attach] && options[:resume]
+        "--attach takes the session id; --resume goes with --shared"
+      elsif conflict
+        "--attach/--shared can't be combined with #{conflict.last}"
+      end
+    end
   end
 end

data/lib/samagotchi/llm/chat_loop.rb

@@ -63,6 +63,11 @@ module Samagotchi
       # The session every request is for; Engine sets it with the adapter.
       # Goes out as a Session-Id header (OpenAIChat#chat).
       attr_accessor :session_id
+      # The last counted request's chars per token
+      # (ContextStatus#counted_chars_per_token), carried to the next turn's
+      # tracker: its first estimate counts the tool schemas the chars leave
+      # out, so the ctx value doesn't dip at each turn's start.
+      attr_accessor :counted_chars_per_token
 
       # @param kernel [KernelLoop] tool dispatch, thought stripping, hooks
       # @param adapter [OpenAIChat, nil] the host to talk to; Engine sets it
@@ -585,7 +590,8 @@ module Samagotchi
           @recovery_repeated = false
           # The names the last request declared deferred.
           @deferred = []
-          @context = ContextStatus.new(conversation: conversation, llm_context: loop.llm_context)
+          @context = ContextStatus.new(conversation: conversation, llm_context: loop.llm_context,
+                                       counted_chars_per_token: loop.counted_chars_per_token)
           loop.llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: @context,
                                                              emit: method(:emit))
         end
@@ -976,6 +982,7 @@ module Samagotchi
                                                    "completion_tokens" => usage.completion_tokens } })
           @context.generation_done(counts, prompt_chars: @request_chars.to_i, image_tokens: @request_image_tokens.to_i,
                                            window: window)
+          @loop.counted_chars_per_token = @context.counted_chars_per_token || @loop.counted_chars_per_token
         end
 
         # The model's answer at debug level, as the native loop dumps its

data/lib/samagotchi/llm_context_forget.rb

@@ -36,7 +36,10 @@ module Samagotchi
   #   to free anything (SMALL), an output already stubbed or forgotten, an
   #   id nothing in context has;
   # - an output the user dropped (WorkingSetSteer): neither forgotten nor
-  #   restored by the model, in WorkingSetSteer::Refused's words.
+  #   restored by the model, in WorkingSetSteer::Refused's words;
+  # - an output of an item the user pinned (+pinned+: WorkingSet.pinned_ids
+  #   of the session's pins), in WorkingSetSteer::Refused's words too (a
+  #   restore of one is fine: it brings the output back).
   # A read is never restored: reading the file again is its restore, and
   # the file may have changed.
   module LLMContextForget
@@ -74,8 +77,10 @@ module Samagotchi
     # call (both loops add the model's entry before its calls run).
     # @param apply [#call] → LLMContextApply::Outcome: the apply rule at a
     #   request, on the turn's conversation (KernelLoop#apply_llm_context!)
+    # @param pinned [#call, nil] conversation → the ids the user's pins
+    #   hold (WorkingSet.pinned_ids), asked only when a forget is asked
     # @return [String] the tool result
-    def call(turn, call, llm_context:, apply:, root: Dir.pwd, now: Time.now.utc.iso8601(3))
+    def call(turn, call, llm_context:, apply:, root: Dir.pwd, pinned: nil, now: Time.now.utc.iso8601(3))
       request = Tools::ForgetOutputs.parse(call)
       conversation = turn.conversation
       return restore(turn, request.restore, llm_context) if request.restore? && request.ids.empty?
@@ -85,7 +90,8 @@ module Samagotchi
                "what's ruled out, NEXT), since it is all that stays of them"
       end
 
-      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now)
+      pinned_ids = pinned ? pinned.call(conversation) : Set.new
+      forgotten, refused = forget(conversation, request, llm_context.protect_steps, root, now, pinned_ids)
       lines = if forgotten.empty?
                 ["nothing forgotten"]
               else
@@ -99,7 +105,7 @@ module Samagotchi
     # Saves a staged forget on each output +request+ names that may go.
     # @return [Array(Array<String>, Hash{String => String})] the ids
     #   forgotten, and the refused ones with why
-    def forget(conversation, request, protect_steps, root, now)
+    def forget(conversation, request, protect_steps, root, now, pinned_ids)
       outputs = outputs(conversation)
       last = LLMContextStale.step_count(conversation)
       # The steps before the call's own: protected_ids counts that one too.
@@ -107,7 +113,7 @@ module Samagotchi
                                                                root: root)
       refused = {}
       forgotten = request.ids.select do |id|
-        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads)
+        why = refusal(conversation, outputs[id], request.keep[id], last, protect_steps, kept_reads, pinned_ids)
         refused[id] = why if why
         why.nil?
       end
@@ -124,11 +130,12 @@ module Samagotchi
     # Why +output+ can't go (a String for the result), nil when it can.
     # +last+: the call's own step; the protect_steps steps before it are
     # the model's latest outputs.
-    def refusal(conversation, output, keep, last, protect_steps, kept_reads)
+    def refusal(conversation, output, keep, last, protect_steps, kept_reads, pinned_ids)
       return "no output with that id in context (ids look like t42)" unless output
 
       held = LLMContextEdit.on(conversation[output.index])[output.ref.id]
       return WorkingSetSteer::Refused.text(:dropped) if held&.kind == LLMContextEdit::DROP
+      return WorkingSetSteer::Refused.text(:pinned_by_user) if pinned_ids.include?(output.ref.id)
       return "already forgotten or stubbed" if held
       if protect_steps.positive? && output.step >= last - protect_steps
         return "from your last #{protect_steps} step#{"s" unless protect_steps == 1}; you may still need it, forget it later"

data/lib/samagotchi/note_command.rb

@@ -6,6 +6,7 @@ require_relative "note_delivery"
 require_relative "session_manager"
 require_relative "cli/command"
 require_relative "cli/flags"
+require_relative "session_access/local"
 
 module Samagotchi
   # `chi note`: push text into sessions as a context note (background the
@@ -33,12 +34,15 @@ module Samagotchi
     end
 
     # @param argv [Array<String>] the arguments after "note"
-    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil)
+    # @param access [SessionAccess::Local, nil] where the sessions are;
+    #   default this machine's, in +state_dir+
+    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, state_dir: nil, access: nil)
       @argv = argv.dup
       @stdin = stdin
       @stdout = stdout
       @stderr = stderr
       @state_dir = state_dir || Session.default_state_dir
+      @access = access || SessionAccess::Local.new(state_dir: @state_dir)
     end
 
     # @return [Integer] exit status: 0 all queued, 1 any refused or failed,
@@ -93,8 +97,7 @@ module Samagotchi
 
     # --all: every live session. @return [Integer] exit status
     def deliver_to_live(text, source)
-      ids = SessionManager.session_summaries(live: true, include_tests: Session.test_session_env?,
-                                             state_dir: @state_dir).map { |s| s[:id] }
+      ids = @access.summaries(live: true, include_tests: Session.test_session_env?).map { |s| s[:id] }
       if ids.empty?
         error_line("chi note: no live sessions (chi sessions list --live --scope=all)")
         return 1
@@ -104,9 +107,7 @@ module Samagotchi
     end
 
     def resolve(given)
-      id = Session.resolve_id(given, state_dir: @state_dir)
-      Session.load(id, state_dir: @state_dir)
-      id
+      @access.resolve(given)
     rescue ArgumentError => e
       message = e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"
       error_line("chi note: #{message}")
@@ -115,7 +116,7 @@ module Samagotchi
 
     # @return [Boolean] whether the note was queued
     def deliver(id, text, source)
-      result = NoteDelivery.deliver(id, text: text, source: source, state_dir: @state_dir)
+      result = @access.note(id, text: text, source: source)
       @stdout.puts("#{id[0, 8]}  #{outcome(result)}")
       result.delivered?
     end

data/lib/samagotchi/owner_lock.rb

@@ -19,17 +19,37 @@ module Samagotchi
     DEFAULT_WAIT = 2.0
     RETRY_INTERVAL = 0.05
     OWNER_READ_ATTEMPTS = 10
+    # Seconds .await_release waits past a leaving worker's own budget: its
+    # last save, the task watch's absorb, its exit.
+    LEAVE_MARGIN = 5.0
+    # Seconds between .await_release's looks at the lock.
+    RELEASE_POLL = 0.1
 
     # Who holds the lock, as .owner reads it from the lock file. Its fields
     # may be nil for a moment right after acquisition.
-    # kind: "worker" or "tui"; pid as written (an Integer).
-    Owner = Data.define(:pid, :kind, :started_at) do
-      def initialize(pid: nil, kind: nil, started_at: nil) = super
+    # kind: "worker" or "tui"; pid as written (an Integer). leaving_at (an
+    # ISO 8601 time) and leave_wait (seconds): set once a worker is leaving
+    # (#mark_leaving), its Bridge closed, the lock held for its last work
+    # (the recap on leave) for up to leave_wait.
+    Owner = Data.define(:pid, :kind, :started_at, :leaving_at, :leave_wait) do
+      def initialize(pid: nil, kind: nil, started_at: nil, leaving_at: nil, leave_wait: nil) = super
 
       # The interactive TUI's: it reads no input files and takes no notes.
       def tui? = kind == "tui"
 
       def worker? = kind == "worker"
+
+      # A worker that closed its Bridge and releases the lock once its
+      # last work is done.
+      def leaving? = worker? && !leaving_at.nil?
+
+      # Seconds of its leave_wait still to run at +now+ (0 when past).
+      def leave_left(now = Time.now)
+        started = Time.iso8601(leaving_at.to_s)
+        [leave_wait.to_f - (now - started), 0.0].max
+      rescue ArgumentError
+        leave_wait.to_f
+      end
     end
 
     # Take the lock, retrying for up to +wait+ seconds (another process's
@@ -71,12 +91,35 @@ module Samagotchi
 
           sleep(RETRY_INTERVAL / 5)
         end
-        Owner.new(pid: data["pid"], kind: data["kind"], started_at: data["started_at"])
+        Owner.new(pid: data["pid"], kind: data["kind"], started_at: data["started_at"],
+                  leaving_at: data["leaving_at"], leave_wait: data["leave_wait"])
       end
     rescue Errno::ENOENT
       nil
     end
 
+    # Wait for a leaving worker (Owner#leaving?) to release the lock: up to
+    # its leave_wait still to run plus LEAVE_MARGIN, looking every
+    # RELEASE_POLL seconds. An owner that isn't leaving (a live worker, a
+    # stuck one, a chi REPL) or no owner returns at once. A Ctrl-C (Interrupt)
+    # stops the wait as it would any sleep.
+    # @param on_wait [#call, nil] called once with the Owner before waiting
+    # @return [Symbol] :not_leaving, :released, or :timeout (still held)
+    def self.await_release(session_dir, on_wait: nil, margin: LEAVE_MARGIN, clock: method(:monotonic_now),
+                           sleeper: method(:sleep), now: -> { Time.now })
+      holder = owner(session_dir)
+      return :not_leaving unless holder&.leaving?
+
+      on_wait&.call(holder)
+      deadline = clock.call + holder.leave_left(now.call) + margin
+      loop do
+        return :released unless owner(session_dir)
+        return :timeout if clock.call >= deadline
+
+        sleeper.call(RELEASE_POLL)
+      end
+    end
+
     def self.path(session_dir)
       File.join(session_dir, FILE)
     end
@@ -99,11 +142,28 @@ module Samagotchi
     def initialize(file, kind:)
       @file = file
       @kind = kind.to_s
+      @record = { "pid" => Process.pid, "kind" => @kind, "started_at" => Time.now.iso8601(3) }
+      write_record
+    end
+
+    # The holder is leaving: its Bridge is closed and it releases the lock
+    # within +wait+ seconds (its recap on leave's timeout), which
+    # .await_release reads. .owner retries the moment the file is empty.
+    # @param wait [Numeric]
+    def mark_leaving(wait:)
+      return if @file.closed?
+
+      @record = @record.merge("leaving_at" => Time.now.iso8601(3), "leave_wait" => wait.to_f)
+      write_record
+    end
+
+    def write_record
       @file.truncate(0)
       @file.rewind
-      @file.write(JSON.generate("pid" => Process.pid, "kind" => @kind, "started_at" => Time.now.iso8601(3)))
+      @file.write(JSON.generate(@record))
       @file.flush
     end
+    private :write_record
 
     # Release the lock (process exit releases it too).
     def release

data/lib/samagotchi/parent_report.rb

@@ -3,6 +3,7 @@
 require "delegate"
 require "json"
 
+require_relative "chi_invocation"
 require_relative "cli/exit"
 require_relative "pending_question"
 require_relative "session"
@@ -81,7 +82,9 @@ module Samagotchi
     # @return [Hash] the --format json object
     # @param strategy [Guardrails::ParentPolicy::Strategy, nil] what a parent
     #   may pick on the waited-for session (#strategy_for); nil: config.yml's
-    def json(result, session_id:, timeout: nil, extra: {}, strategy: nil)
+    # @param via [ChiInvocation] how the printed commands are spelled (this
+    #   machine's chi, or chi --remote NAME); each function here takes it
+    def json(result, session_id:, timeout: nil, extra: {}, strategy: nil, via: ChiInvocation::HERE)
       report = { status: status(result), session_id: session_id }
       report[:turn_id] = result.turn_id unless result.turn_id.to_s.empty?
       case report[:status]
@@ -89,10 +92,10 @@ module Samagotchi
       when "question"
         question = question(result.question, strategy: strategy)
         report[:question] = question
-        report[:answer_with] = answer_with(session_id, question)
+        report[:answer_with] = answer_with(session_id, question, via: via)
       else
         report.merge!(stop_facts(result))
-        report[:detail] = detail(result, session_id: session_id, timeout: timeout, strategy: strategy)
+        report[:detail] = detail(result, session_id: session_id, timeout: timeout, strategy: strategy, via: via)
       end
       report.merge(extra)
     end
@@ -110,8 +113,8 @@ module Samagotchi
     end
 
     # @return [String] the JSON object as one line
-    def json_line(result, session_id:, timeout: nil, extra: {}, strategy: nil)
-      JSON.generate(json(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy))
+    def json_line(result, session_id:, timeout: nil, extra: {}, strategy: nil, via: ChiInvocation::HERE)
+      JSON.generate(json(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy, via: via))
     end
 
     # Print a wait's end the way the commands do: the JSON object on
@@ -120,17 +123,19 @@ module Samagotchi
     # @param command [String] "chi send", "chi answer"
     # @param extra [Hash] more keys for the JSON object (#json)
     # @return [Integer] the exit status
-    def report(result, session_id:, stdout:, stderr:, command:, json: false, timeout: nil, extra: {}, strategy: nil)
+    def report(result, session_id:, stdout:, stderr:, command:, json: false, timeout: nil, extra: {}, strategy: nil,
+               via: ChiInvocation::HERE)
       if json
-        stdout.puts(json_line(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy))
+        stdout.puts(json_line(result, session_id: session_id, timeout: timeout, extra: extra, strategy: strategy, via: via))
       elsif result.status == :done
         stdout.puts(result.text)
       else
         stdout.flush
         text = if result.status == :waiting_for_answer
-                 question_text(result.question, session_id: session_id, strategy: strategy)
+                 question_text(result.question, session_id: session_id, strategy: strategy, via: via)
                else
-                 "#{detail(result, session_id: session_id, timeout: timeout, turn_id: result.turn_id, strategy: strategy)}\n"
+                 "#{detail(result, session_id: session_id, timeout: timeout, turn_id: result.turn_id, strategy: strategy,
+                                   via: via)}\n"
                end
         stderr.print("#{command}: #{text}")
       end
@@ -177,16 +182,22 @@ module Samagotchi
     # lists an Allow once a parent may give). A step-limit question's
     # continues the turn, or stops it where a parent may not continue (its
     # other form is in #question_text).
-    def answer_with(session_id, question)
-      return "chi answer #{session_id} --question #{question[:id]} --option Deny --text WHY" if approval?(question)
-      return stop_command(session_id, question) if continue?(question) && !may_continue?(question)
-      return "chi answer #{session_id} --question #{question[:id]} --option Continue" if continue?(question)
+    def answer_with(session_id, question, via: ChiInvocation::HERE)
+      return answer_command(session_id, question, "Deny --text WHY", via: via) if approval?(question)
+      return stop_command(session_id, question, via: via) if continue?(question) && !may_continue?(question)
+      return answer_command(session_id, question, "Continue", via: via) if continue?(question)
 
       # The one option a parent may pick (cost-cap's Stop under hard).
       only = Array(question[:allowed_options])
-      return "chi answer #{session_id} --question #{question[:id]} --option #{option_arg(only.first)}" if only.size == 1
+      return answer_command(session_id, question, option_arg(only.first), via: via) if only.size == 1
 
-      "chi answer #{session_id} --question #{question[:id]} --option N"
+      answer_command(session_id, question, "N", via: via)
+    end
+
+    # chi answer ID --question QID --option +option+ (its words after
+    # --option: a label, maybe --text).
+    def answer_command(session_id, question, option, via: ChiInvocation::HERE)
+      via.command("answer #{session_id} --question #{question[:id]} --option #{option}")
     end
 
     # What a parent does with an approval it may not allow.
@@ -239,17 +250,18 @@ module Samagotchi
       question.fetch(:allowed_options, question[:options]).include?(Guardrails::ParentPolicy::CONTINUE)
     end
 
-    def stop_command(session_id, question)
-      "chi answer #{session_id} --question #{question[:id]} --option Stop --text WHY"
+    def stop_command(session_id, question, via: ChiInvocation::HERE)
+      answer_command(session_id, question, "Stop --text WHY", via: via)
     end
 
     def option_arg(label) = label.match?(/\A[\w.-]+\z/) ? label : label.inspect
 
     # The other way: the user answers it in chi (the web's bell and badge
     # say it waits), and a wait with no message waits past it.
-    def leave_open(session_id)
-      "or leave it open: tell your user it waits in chi web (session #{session_id[0, 8]}); " \
-        "chi send --wait --format json #{session_id} waits until they answer"
+    def leave_open(session_id, via: ChiInvocation::HERE)
+      web = via.remote? ? via.web : "chi web"
+      "or leave it open: tell your user it waits in #{web} (session #{session_id[0, 8]}); " \
+        "#{via.command("send --wait --format json #{session_id}")} waits until they answer"
     end
 
     # @param question [PendingQuestion, Hash, nil] a pending question, or a
@@ -267,13 +279,13 @@ module Samagotchi
     end
 
     # What a message does to a step-limit question.
-    def message_drops(session_id)
-      "a message instead (chi send #{session_id} -m …) drops it and starts a new turn"
+    def message_drops(session_id, via: ChiInvocation::HERE)
+      "a message instead (#{via.command("send #{session_id} -m …")}) drops it and starts a new turn"
     end
 
     # What a wait that ended without an answer says, one line.
-    def detail(result, session_id:, timeout: nil, turn_id: nil, strategy: nil)
-      attach = "chi --attach #{session_id}"
+    def detail(result, session_id:, timeout: nil, turn_id: nil, strategy: nil, via: ChiInvocation::HERE)
+      shows = via.shows(session_id)
       case result.status
       when :waiting_for_answer
         q = question(result.question, strategy: strategy)
@@ -281,20 +293,20 @@ module Samagotchi
           "waiting for an approval: #{first_line(q[:text])}; #{approval_advice(q, strategy: strategy)}"
         elsif continue?(q) && !may_continue?(q)
           "waiting at the step limit: #{first_line(q[:text])}; a parent may only stop it here " \
-            "(#{policy(strategy).label}): #{stop_command(session_id, q)}, or tell your user it waits"
+            "(#{policy(strategy).label}): #{stop_command(session_id, q, via: via)}, or tell your user it waits"
         elsif continue?(q)
           "waiting at the step limit: #{first_line(q[:text])}; " \
-            "answer Continue or Stop: chi answer #{session_id} --question #{q[:id]} --option Continue"
+            "answer Continue or Stop: #{answer_command(session_id, q, "Continue", via: via)}"
         else
-          "waiting for an answer: #{first_line(q[:text])}; open it: #{attach} or the web"
+          "waiting for an answer: #{first_line(q[:text])}; open it: #{via.open_it(session_id)}"
         end
-      when :no_reply then "#{no_reply_line(result, session_id, strategy: strategy)}; #{attach} shows it"
-      when :error then "the worker failed: #{result.text}; #{attach} shows what happened"
-      when :worker_gone then "the worker is gone; #{attach} shows what happened"
+      when :no_reply then "#{no_reply_line(result, session_id, strategy: strategy, via: via)}; #{shows} shows it"
+      when :error then "the worker failed: #{result.text}; #{shows} shows what happened"
+      when :worker_gone then "the worker is gone; #{shows} shows what happened"
       when :stopped then "the session was stopped (chi sessions stop)"
       else
-        wait_again = "chi send --wait --turn #{turn_id} #{session_id}" unless turn_id.to_s.empty?
-        hint = wait_again || attach
+        wait_again = via.command("send --wait --turn #{turn_id} #{session_id}") unless turn_id.to_s.empty?
+        hint = wait_again || shows
         timeout ? "still running after #{format("%g", timeout)} s: #{hint}" : "still running: #{hint}"
       end
     end
@@ -302,7 +314,7 @@ module Samagotchi
     # The whole question for stderr: header, text, numbered options, what
     # else it takes, and the commands that answer it.
     # @return [String] lines, newline-terminated
-    def question_text(pending, session_id:, strategy: nil)
+    def question_text(pending, session_id:, strategy: nil, via: ChiInvocation::HERE)
       q = question(pending, strategy: strategy)
       lines = ["waiting for an answer (#{q[:kind]}): #{q[:header] || first_line(q[:text])}"]
       text_lines = q[:text].strip.lines.map(&:rstrip)
@@ -315,31 +327,31 @@ module Samagotchi
           lines << "  allowing it is up to your user: #{DENY_AND_TELL}"
         else
           lines << "  #{approval_advice(q, strategy: strategy)}"
-          allows.each { |label| lines << "  allow: chi answer #{session_id} --question #{q[:id]} --option #{option_arg(label)}" }
+          allows.each { |label| lines << "  allow: #{answer_command(session_id, q, option_arg(label), via: via)}" }
         end
-        lines << "  deny: #{answer_with(session_id, q)}"
-        lines << "  #{leave_open(session_id)}"
+        lines << "  deny: #{answer_with(session_id, q, via: via)}"
+        lines << "  #{leave_open(session_id, via: via)}"
       elsif continue?(q)
         lines << if may_continue?(q)
-                   "  continue: #{answer_with(session_id, q)}"
+                   "  continue: #{answer_with(session_id, q, via: via)}"
                  else
                    "  continuing it is up to your user (#{policy(strategy).label}): stop it, or tell your user it waits"
                  end
-        lines << "  stop: #{stop_command(session_id, q)} (the text is optional; the model reads it)"
-        lines << "  #{message_drops(session_id)}"
+        lines << "  stop: #{stop_command(session_id, q, via: via)} (the text is optional; the model reads it)"
+        lines << "  #{message_drops(session_id, via: via)}"
       else
         lines << "  more than one allowed: repeat --option" if q[:multi_select]
         lines << "  free text allowed: --text" if q[:allow_freeform]
         if q[:allowed_options]
           lines << "  a parent may pick #{q[:allowed_options].map { |o| option_arg(o) }.join(", ")}; the others are up to your user"
         end
-        lines << "  answer: #{answer_with(session_id, q)}"
-        lines << "  or open it: chi --attach #{session_id} or the web"
+        lines << "  answer: #{answer_with(session_id, q, via: via)}"
+        lines << "  or open it: #{via.open_it(session_id)}"
       end
       lines.map { |line| "#{line}\n" }.join
     end
 
-    def no_reply_line(result, session_id = nil, strategy: nil)
+    def no_reply_line(result, session_id = nil, strategy: nil, via: ChiInvocation::HERE)
       return command_line(result) if result.origin == TurnCheckpoint::COMMAND_ORIGIN
 
       case result.outcome
@@ -354,7 +366,7 @@ module Samagotchi
         ran_out = "the turn ran out of iterations#{" (#{result.limit} steps)" if result.limit} before it answered"
         strategy = policy(strategy)
         if strategy.allow?(Guardrails::ParentPolicy::SPEND)
-          "#{ran_out}; chi send #{session_id} -m '/continue yes' continues it, a message drops it"
+          "#{ran_out}; #{via.command("send #{session_id} -m '/continue yes'")} continues it, a message drops it"
         else
           # No /continue yes hint: a parent may not continue it here.
           "#{ran_out}; continuing it is up to your user (#{strategy.label}), a message drops it"