samagotchi 0.50.0 → 0.52.0

data/lib/samagotchi/session_commands.rb

@@ -11,6 +11,7 @@ require_relative "tools/context_read"
 require_relative "tools/peers"
 require_relative "commands/registry"
 require_relative "llm_context_command"
+require_relative "thinking_command"
 
 module Samagotchi
   # The session commands a REPL and a session worker both run: /model,
@@ -29,6 +30,7 @@ module Samagotchi
     CONTEXT_COMMAND = "/context"
     HELP_COMMAND = "/help"
     LLM_CONTEXT_COMMAND = LLMContextCommand::NAME
+    THINKING_COMMAND = ThinkingCommand::NAME
     # A remote catalog has hundreds of ids (OpenRouter ~380): plain /models
     # shows this many per host; /models <text> lists every match.
     MODELS_PER_HOST = 20
@@ -88,6 +90,8 @@ module Samagotchi
       # Setting it saves the session; it takes effect at the next turn's start.
       registry.register(LLM_CONTEXT_COMMAND, "show or set this session's LLM context strategy, apply rule and budget",
                         id: :llm_context, mid_turn: show_mid_turn(LLM_CONTEXT_COMMAND), match: ->(text) { text.match?(%r{\A/llm-context(?:\s+.*)?\z}) }) { |text| llm_context(text) }
+      registry.register(THINKING_COMMAND, "show or set this session's thinking level (off|low|medium|high|default)",
+                        id: :thinking, mid_turn: show_mid_turn(THINKING_COMMAND), match: ->(text) { text.match?(%r{\A/thinking(?:\s+.*)?\z}) }) { |text| thinking(text) }
       registry.register(HELP_COMMAND, "list the commands, the bundles' too", anytime: true) { |_text| reply(help_listing) }
       registry.register("/stats", "show the session's stats", local: true)
       registry.register("/recap", "show the session's recap", local: true)
@@ -100,6 +104,16 @@ module Samagotchi
       # The REPL owns its session: it answers /detach with a note, and doesn't offer it.
       registry.register("/detach", "leave and keep the worker running", local: true, uis: [:attached],
                                                                         match: ->(text) { text.casecmp?("/detach") })
+      # /cut TEXT and /queue TEXT while a turn runs: a delivery the UIs parse
+      # themselves (Formatting#steer_choice) before any command check; the
+      # entries exist for Tab completion and /help. The web composer sends
+      # /cut too. /queue is a real after-the-turn list only in the local
+      # REPL (the attached TUI's worker doesn't skip queued files yet), so
+      # it is offered there.
+      registry.register("/cut", "cut the running generation and go in now (/cut TEXT)",
+                        local: true, uis: %i[repl attached web], match: ->(text) { text.casecmp?("/cut") || text.match?(%r{\A/cut\s+\S}) })
+      registry.register("/queue", "run as the next turn after this one (/queue TEXT)",
+                        local: true, uis: [:repl], match: ->(text) { text.casecmp?("/queue") || text.match?(%r{\A/queue\s+\S}) })
       registry
     end
 
@@ -166,13 +180,26 @@ module Samagotchi
         notes = []
         notes << entry.source unless entry.source == "core"
         notes << MID_TURN_NOTES[entry.mid_turn_label] if MID_TURN_NOTES[entry.mid_turn_label]
-        notes << (entry.uis ? "#{entry.uis.join(" and ")} only" : "terminal only") if entry.local
+        notes << "#{ui_words(entry.uis)} only" if entry.local
         line = "  #{self.class.display_name(entry).ljust(width)}  #{entry.description}"
         notes.empty? ? line : "#{line}  (#{notes.join("; ")})"
       end
       "commands:\n#{lines.join("\n")}"
     end
 
+    # Where a UI's own entry runs, for /help: both terminals are
+    # "terminal" (also for no uis: every terminal), then "web".
+    # @param uis [Array<Symbol>, nil]
+    # @return [String] "terminal", "repl", "terminal and web" …
+    def ui_words(uis)
+      return "terminal" if uis.nil?
+
+      terminals = uis & %i[repl attached]
+      words = terminals.size == 2 ? ["terminal"] : terminals.map(&:to_s)
+      words << "web" if uis.include?(:web)
+      words.join(" and ")
+    end
+
     # How help and errors name an entry (the shell's "!" is "!<cmd>").
     def self.display_name(entry) = entry.name == SHELL_BANG_PREFIX ? "#{SHELL_BANG_PREFIX}<cmd>" : entry.name
 
@@ -363,14 +390,25 @@ module Samagotchi
     # /llm-context (LLMContextCommand); :llm_context in changed when it set
     # the session's values.
     def llm_context(text)
-      output, changed = LLMContextCommand.new(engine: @engine, save: ->(session) { save_llm_context(session) })
+      output, changed = LLMContextCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
                                          .run(text.delete_prefix(LLM_CONTEXT_COMMAND))
       reply(output, changed: changed ? [:llm_context] : [])
     rescue ArgumentError => e
       reply(e.message, status: :error)
     end
 
-    def save_llm_context(session)
+    # /thinking (ThinkingCommand); :thinking in changed when it set the
+    # session's level.
+    def thinking(text)
+      output, changed = ThinkingCommand.new(engine: @engine, save: ->(session) { save_setup(session) })
+                                       .run(text.delete_prefix(THINKING_COMMAND))
+      reply(output, changed: changed ? [:thinking] : [])
+    rescue ArgumentError => e
+      reply(e.message, status: :error)
+    end
+
+    # A session setting changed (/llm-context, /thinking): saved with its model.
+    def save_setup(session)
       @engine.store_model!(session)
       @save.call(session)
     end

data/lib/samagotchi/session_inbox.rb

@@ -5,6 +5,7 @@ require "json"
 require "time"
 require "securerandom"
 require_relative "atomic_file"
+require_relative "delivery"
 require_relative "session"
 
 module Samagotchi
@@ -34,12 +35,18 @@ module Samagotchi
     class NoteRejected < ArgumentError; end
 
     # Queue a turn's input file: JSON with the prompt and the sender's ids.
+    # +delivery+ is only written when it is "queue": a step-boundary
+    # message is the default an older worker assumes, and a cut is done by
+    # the sender (the Bridge) at once, not by the file.
     # @param client_id [String, nil] the sending UI
     # @param enqueued_id [String, nil] the id its ACK / :turn_enqueued carry
+    # @param delivery [String, nil] the wire value: "next_step" (default),
+    #   "cut" or "queue"
     # @param images [Array<Hash>] image refs ({file:, name:}) in the
     #   session's images/
     # @return [String, false] the input file's path, or false
-    def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [])
+    def self.write_input(session_dir, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, images: [],
+                         delivery: nil)
       images = Array(images)
       input_dir = File.join(session_dir, INPUT_DIR)
       FileUtils.mkdir_p(input_dir)
@@ -47,6 +54,7 @@ module Samagotchi
       path = File.join(input_dir, "#{Time.now.strftime("%Y%m%d%H%M%S%9N")}.json")
       record = { "prompt" => prompt.to_s, "client_id" => client_id, "enqueued_id" => enqueued_id,
                  "no_interrupt" => (no_interrupt ? true : nil),
+                 "delivery" => (Delivery.queue?(delivery) ? Delivery::QUEUE : nil),
                  "images" => (images.empty? ? nil : images.map { |image| image.transform_keys(&:to_s) }) }.compact
       AtomicFile.write(path, JSON.generate(record))
       path
@@ -175,17 +183,29 @@ module Samagotchi
       Dir.glob(File.join(input_dir, "*.json"))
     end
 
-    # @return [Array(String, Hash|nil, Boolean, Array<Hash>)] a claimed input
-    #   file's prompt, origin ({client_id:, enqueued_id:}, nil when it names
-    #   no sender), whether its turn runs with the raised iteration limit
-    #   (--no-interrupt), and its image refs ({file:, name:})
+    # A claimed input file as read: its +prompt+, +origin+ ({client_id:,
+    # enqueued_id:}, nil when it names no sender), whether its turn runs
+    # with the raised iteration limit (+no_interrupt+, --no-interrupt), its
+    # +images+ ({file:, name:} refs), and its +delivery+ ("queue" or nil; a
+    # file without the key is one an older chi wrote, so nil).
+    Input = Data.define(:prompt, :origin, :no_interrupt, :images, :delivery) do
+      def initialize(prompt:, origin: nil, no_interrupt: false, images: [], delivery: nil) = super
+    end
+    # A file that doesn't parse, or isn't a JSON object: no prompt.
+    UNREADABLE_INPUT = Input.new(prompt: nil)
+
+    # @return [Input] a claimed input file's contents; UNREADABLE_INPUT for
+    #   one that isn't a JSON object
     def self.read_input(claimed_file)
       data = JSON.parse(File.read(claimed_file).to_s)
+      return UNREADABLE_INPUT unless data.is_a?(Hash)
+
       origin = { client_id: data["client_id"], enqueued_id: data["enqueued_id"] }.compact
       images = Array(data["images"]).select { |image| image.is_a?(Hash) }.map { |image| image.transform_keys(&:to_sym) }
-      [data["prompt"].to_s, origin.empty? ? nil : origin, data["no_interrupt"] == true, images]
+      Input.new(prompt: data["prompt"].to_s, origin: origin.empty? ? nil : origin, no_interrupt: data["no_interrupt"] == true,
+                images: images, delivery: Delivery.queue?(data["delivery"]) ? Delivery::QUEUE : nil)
     rescue JSON::ParserError
-      [nil, nil, false, []]
+      UNREADABLE_INPUT
     end
 
     # Whether an unclaimed input file carries images (a mid-turn drain
@@ -197,6 +217,15 @@ module Samagotchi
       false
     end
 
+    # Whether a mid-turn drain leaves this unclaimed input file for a turn
+    # of its own instead of merging it at a step boundary. Today that is an
+    # image message (steering merges text only); the drain's file filter
+    # reads this one predicate, so what a boundary refuses changes in one
+    # place.
+    def self.waits_for_turn_end?(input_file)
+      input_has_images?(input_file)
+    end
+
     def self.claim_input_file(input_file)
       processing_path = "#{input_file}.processing"
       File.rename(input_file, processing_path)

data/lib/samagotchi/session_manager.rb

@@ -8,11 +8,13 @@ require "rbconfig"
 require_relative "client_id"
 require_relative "atomic_file"
 require_relative "config"
+require_relative "delivery"
 
 require_relative "session"
 require_relative "session_inbox"
 require_relative "session_metrics"
 require_relative "llm_context_strategy"
+require_relative "session_setup"
 require_relative "host_registry"
 require_relative "utf8_default"
 require_relative "turn_note"
@@ -162,8 +164,8 @@ module Samagotchi
     # @param images_from [String, nil] the session dir the seed's images are in
     # @param title [String, nil] what the lists show before the first turn
     #   (the prompt's preview by default, else the seed's first user message)
-    # @param llm_context [LLMContextOverride, nil] the session's own
-    #   llm_context values (chi --llm-context; a fork copies its parent's)
+    # @param setup [SessionSetup] the session's own settings (chi
+    #   --llm-context; a fork and a continue copy their session's)
     # @param continues [String, nil] the session this one continues (a
     #   session field; #continue_session)
     # @param note [String, nil] a context note the session starts with,
@@ -175,7 +177,7 @@ module Samagotchi
     #   and #model_warning: an id its host's saved list doesn't have
     def self.spawn_session(prompt:, mode: "assist", working_directory: nil, model_name: nil, state_dir: nil,
                            memories: [], muted_memories: [], parent_id: nil, messages: [], images_from: nil,
-                           title: nil, delegate: false, llm_context: nil, continues: nil, note: nil,
+                           title: nil, delegate: false, setup: SessionSetup.new, continues: nil, note: nil,
                            note_source: "chi", before_spawn: nil)
       sd = state_dir || Session.default_state_dir
       # The resolved ref is stored (a resumed session keeps its model when an
@@ -197,7 +199,7 @@ module Samagotchi
         parent_id: parent_id,
         messages: messages,
         delegate: delegate,
-        llm_context: llm_context,
+        setup: setup,
         continues: continues
       )
       session.model_warning = model_warning
@@ -231,7 +233,7 @@ module Samagotchi
 
     # Start the next link of a chain: a new session that continues
     # +id_or_ref+ (Session#continues) in its folder, on its model (the name
-    # it was typed as, so an alias holds) and with its own llm_context,
+    # it was typed as, so an alias holds) and with its own setup (SessionSetup),
     # starting with a context note from chi: the link and the previous
     # link's recap (SessionChain.note_text). The previous link is archived
     # first, with its finished delegates (archive_session's rules: a turn
@@ -362,7 +364,7 @@ module Samagotchi
         ChildMove.apply(move, from: previous.id, to: link.id, state_dir: state_dir)
       end
       link = spawn_session(prompt: start, title: title, working_directory: previous.working_directory,
-                           model_name: previous.model_typed || previous.model_name, llm_context: previous.llm_context,
+                           model_name: previous.model_typed || previous.model_name, setup: SessionSetup.of(previous),
                            continues: previous.id, note: SessionChain.note_text(previous, recap: recap),
                            note_source: SessionChain::NOTE_SOURCE, state_dir: state_dir, before_spawn: before_spawn)
       link.moved_children = move
@@ -514,7 +516,7 @@ module Samagotchi
 
     GUARDRAILS_ENV_PREFIX = "SAMAGOTCHI_GUARDRAILS_"
     # Tools::Builtins.parent_env's (Tools::TaskRuntime::MARKER_ENV_KEYS).
-    SESSION_MARKER_ENV = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL].freeze
+    SESSION_MARKER_ENV = %w[SAMAGOTCHI_PARENT_SESSION SAMAGOTCHI_SESSION_MODEL SAMAGOTCHI_SESSION_THINKING].freeze
 
     # List all sessions, reading status from persisted session.json files.
     # +project_root+: only that project's sessions (nil: every session).
@@ -1288,14 +1290,16 @@ module Samagotchi
     # boundary. The file is JSON carrying the sender's ids.
     # @param client_id [String, nil] the sending UI
     # @param enqueued_id [String, nil] the id its ACK / :turn_enqueued carry
+    # @param delivery [String, nil] the wire value: "next_step" (default),
+    #   "cut" or "queue"
     # @param images [Array<Hash>] image refs ({file:, name:}) in the
     #   session's images/
     # @return [String, false] the input file's path, or false.
     def self.write_turn_input(session_id, prompt:, client_id: nil, enqueued_id: nil, no_interrupt: false, state_dir: nil,
-                              images: [])
+                              images: [], delivery: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       SessionInbox.write_input(session_dir, prompt: prompt, client_id: client_id, enqueued_id: enqueued_id,
-                                            no_interrupt: no_interrupt, images: images)
+                                            no_interrupt: no_interrupt, images: images, delivery: delivery)
     end
 
     # How long a turn waits for the Bridge of a worker a resume just spawned.
@@ -1308,6 +1312,8 @@ module Samagotchi
     # exit). Race-safe against a TUI taking the session, or the worker
     # exiting, between the resume and the write.
     # @param images [Array<Hash>] refs ({file:, name:}) already in images/
+    # @param delivery [String, nil] what the message asks the running turn
+    #   for: "next_step" (default), "cut" or "queue"
     # @param manager [#resume_session, #write_turn_input] this class, or a
     #   stand-in (the web's specs); #session_owner is optional
     # @param bridge [#call, nil] returns the BridgeClient or nil; defaults to
@@ -1319,7 +1325,8 @@ module Samagotchi
     #   {status: :failed} when the input file couldn't be written
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
-    def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], state_dir: nil, manager: self, bridge: nil)
+    def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, state_dir: nil, manager: self,
+                          bridge: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
@@ -1327,6 +1334,9 @@ module Samagotchi
         begin
           options = { prompt: prompt, client_id: client_id }
           options[:images] = images unless images.empty?
+          # An old worker ignores the field: it cuts anyway (its own default)
+          # and its file never carries a queue, so a queue would steer there.
+          options[:delivery] = delivery unless Delivery.next_step?(delivery)
           reply = client.post_turn(**options)
           ack = reply.json
           return { status: :accepted, ack: ack } if reply.status == 202 && ack.is_a?(Hash)
@@ -1347,6 +1357,7 @@ module Samagotchi
       enqueued_id = SecureRandom.uuid
       input = { prompt: prompt, client_id: client_id, enqueued_id: enqueued_id, state_dir: state_dir }
       input[:images] = images unless images.empty?
+      input[:delivery] = delivery unless Delivery.next_step?(delivery)
       path = manager.write_turn_input(session_id, **input)
       return { status: :failed } unless path
 

data/lib/samagotchi/session_metrics.rb

@@ -379,6 +379,16 @@ module Samagotchi
       @mutex.synchronize { build_snapshot(:recent) }
     end
 
+    # The snapshot of a session no worker runs, read from disk (`chi
+    # sessions stats`): #snapshot's, but its records are the newest saved
+    # turn's (and its tool calls), as a live worker's snapshot carries its
+    # newest finished turn; #snapshot would list none, this collector having
+    # finished no turn of its own.
+    # @return [Hash]
+    def saved_snapshot
+      @mutex.synchronize { build_snapshot(:last) }
+    end
+
     # Close the open generation now, ahead of its :generation_completed
     # (which then finds it closed), and report its speed with the session's
     # running token totals: what the event carries to the UIs.
@@ -441,6 +451,9 @@ module Samagotchi
         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),
+        # The calls the model made under an alias's name (bash run as
+        # execute), by its own spelling; only when there are any.
+        **(totals[:aliased].empty? ? {} : { tool_calls_aliased: totals[:aliased].dup }),
         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,
@@ -486,14 +499,16 @@ module Samagotchi
 
     # 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.
+    # and the unsaved ones (capped); :last the newest turn, loaded or not;
+    # 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)
+      fresh = @turn_records.size > @loaded_turns ? 1 : 0
+      count = mode == :last ? 1 : unsaved.clamp(fresh, LIVE_RECORDS_CAP)
       turns = @turn_records.last(count)
       ids = turns.to_set { |record| record[:id] }
       ids << @turn.id if @turn
@@ -807,6 +822,8 @@ module Samagotchi
         active = @turn.tool_calls_by_id.delete(key)
         return unless active
 
+        called_as = event.dig(:activity, :called_as)
+        active[:called_as] = called_as.to_s if called_as
         finish_tool_record(active, status.empty? ? "ok" : status, waited_ms: event[:waited_ms].to_i)
       end
     end
@@ -814,7 +831,7 @@ module Samagotchi
     # Caller holds the mutex.
     def finish_tool_record(active, status, waited_ms: 0)
       record = active.slice(
-        :id, :turn_id, :iteration, :call_index, :tool, :started_at
+        :id, :turn_id, :iteration, :call_index, :tool, :called_as, :started_at
       ).merge(
         status: status,
         completed_at: now.iso8601(3),
@@ -1020,7 +1037,7 @@ module Samagotchi
     # (#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, cuts: 0, capped: 0, by_tool: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
+                  gen_ms: 0, retries: 0, cuts: 0, capped: 0, by_tool: {}, aliased: {}, tool_errors: 0, cached_sum: 0, cache_write_sum: 0,
                   reprefill_sum: 0, reasoning_sum: 0,
                   cost_sum: 0, cost_estimate_sum: 0, decode_ms_sum: 0, decode_tokens_sum: 0, last_decode_tps: nil,
                   last_prefill_tps: nil, tps_source: nil }
@@ -1057,6 +1074,8 @@ module Samagotchi
     def count_tool(record)
       @totals[:tool_errors] += 1 if record[:status] == "error"
       tally_into(@totals[:by_tool], [record])
+      called_as = record[:called_as].to_s
+      @totals[:aliased][called_as] = @totals[:aliased].fetch(called_as, 0) + 1 unless called_as.empty?
     end
 
     def tally_into(counts, tools)

data/lib/samagotchi/session_setup.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "llm_context_override"
+require_relative "thinking"
+
+module Samagotchi
+  # A session's own settings that come before its model's, carried as one
+  # value on the paths that spawn a session from a whole setup
+  # (SessionManager.spawn_session, a continue, a plugin's fork, the web's
+  # create, chi send --new): +llm_context+ is an LLMContextOverride or nil,
+  # +thinking+ a level Symbol (Thinking.session_level) or nil.
+  #
+  # It doesn't save itself: the session keeps each setting in its own field
+  # and file key, and resolves it on its own. A delegate child starts
+  # without one; a continue and a fork copy their session's (.of).
+  SessionSetup = Data.define(:llm_context, :thinking) do
+    def initialize(llm_context: nil, thinking: nil) = super
+
+    def empty? = llm_context.nil? && thinking.nil?
+
+    # A session's own setup, for a session that starts from it.
+    # @param session [Session, nil]
+    # @return [SessionSetup]
+    def self.of(session)
+      return new if session.nil?
+
+      new(llm_context: session.llm_context, thinking: session.thinking)
+    end
+  end
+end

data/lib/samagotchi/sessions_command.rb

@@ -339,7 +339,7 @@ module Samagotchi
       end
       return [nil, false, nil] unless File.file?(File.join(dir, "analytics.json"))
 
-      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.snapshot
+      snapshot = Samagotchi::SessionMetrics.new.tap { |m| m.session_id = session.id }.saved_snapshot
       note = live_worker?(session.id) ? "(no live worker answered; from the saved analytics.json)" : nil
       [snapshot, false, note]
     end

data/lib/samagotchi/steer_cut.rb

@@ -22,6 +22,13 @@ module Samagotchi
       { thinking: event[:thinking].to_s, text: text.to_s }
     end
 
+    # steer.cut_after: how long a generation streams only thinking before a
+    # message may cut it, in whole seconds (0 or less: cutting is off).
+    # @return [Integer]
+    def self.cut_after
+      Config.get("steer.cut_after").to_i
+    end
+
     # +clock+: monotonic seconds; +controller+: the running turn's cancel
     # controller (nil between turns), read only when a cut is due.
     def initialize(clock:, controller:)
@@ -44,21 +51,25 @@ module Samagotchi
     # Call it after the message is queued, with the #input_epoch read
     # before queueing it. Outside any lock; a cut that lands just after the
     # generation ended is harmless (the loop re-asks).
-    # @return [Boolean] whether a generation was cut now
+    # @return [Symbol] :now (a generation was cut now), :waits (the message
+    #   waits for the thinking to pass steer.cut_after), or :off (cutting
+    #   off for this source: a plugin, no turn, cut_after 0, a generation
+    #   that isn't thinking-only, or a drain already took the message)
     def cut_for_steer(source, epoch: nil)
-      return false unless Steer.cuts?(source)
+      return :off unless Steer.cuts?(source)
 
-      after = Config.get("steer.cut_after").to_i
-      return false unless after.positive?
+      after = self.class.cut_after
+      return :off unless after.positive?
 
       ctrl = @controller.call
-      return false unless ctrl
-      return cut!(ctrl, source.to_s) if @phase.cuttable?(after)
+      return :off unless ctrl
+      return cut!(ctrl, source.to_s) ? :now : :off if @phase.cuttable?(after)
 
-      Log.info(:turn, "steer_cut_waits", source: source.to_s) if @waiting.wait!(source, epoch: epoch)
-      false
+      waited = @waiting.wait!(source, epoch: epoch)
+      Log.info(:turn, "steer_cut_waits", source: source.to_s) if waited
+      waited ? :waits : :off
     rescue StandardError
-      false
+      :off
     end
 
     # The drains that took input so far (WaitingSteer#epoch): read it before
@@ -100,7 +111,7 @@ module Samagotchi
     def recheck
       return unless @waiting.waiting?
 
-      after = Config.get("steer.cut_after").to_i
+      after = self.class.cut_after
       return unless after.positive? && @phase.cuttable?(after)
 
       source = @waiting.take

data/lib/samagotchi/terminal_ui/attach_launcher.rb

@@ -4,6 +4,7 @@ require_relative "../session"
 require_relative "../config"
 require_relative "../model_profile"
 require_relative "../session_manager"
+require_relative "../thinking_command"
 require_relative "../bridge_client"
 require_relative "../parent_report"
 require_relative "../cli/exit"
@@ -40,16 +41,20 @@ module Samagotchi
       #   (LLMContextOverride.update): a new session starts with them; a
       #   resumed or attached one's worker gets a /llm-context, after the
       #   /model
+      # @param thinking [String, nil] --thinking as typed: a new session
+      #   starts with it as its own level; a resumed or attached one's
+      #   worker gets a /thinking, after those
       # @return [Symbol] :detached, :closed when the worker went away,
       #   :failed when the --model switch didn't go through, or (input from a
       #   pipe) :turn_failed / :empty_answer / :unanswered (AttachedLoop#run)
       def run(attach: nil, shared: false, resume: nil, prompt: nil, model: nil, no_interrupt: false, default_input: true,
-              memories: [], muted_memories: [], llm_context: {})
+              memories: [], muted_memories: [], llm_context: {}, thinking: nil)
         client = connect(attach: attach, shared: shared, resume: resume, model: model,
-                         memories: memories, muted_memories: muted_memories, llm_context: llm_context)
+                         memories: memories, muted_memories: muted_memories, llm_context: llm_context, thinking: thinking)
         commands = []
         commands << "/model #{model}" if model && (attach || resume)
         commands << LLMContextOverride.command_line(llm_context) if (attach || resume) && !llm_context.empty?
+        commands << "#{ThinkingCommand::NAME} #{thinking}" if (attach || resume) && thinking
         first_command = commands.size > 1 ? commands : commands.first
         surface = open_surface
         attached = AttachedLoop.new(client: client, screen: surface, client_id: "tui:#{Process.pid}", first_prompt: prompt,
@@ -111,7 +116,7 @@ module Samagotchi
       # @return [BridgeClient] a client for the live Bridge of the session
       # @raise [Error]
       def connect(attach: nil, shared: false, resume: nil, model: nil, state_dir: nil, wait: BRIDGE_WAIT,
-                  memories: [], muted_memories: [], llm_context: {}, err: $stderr)
+                  memories: [], muted_memories: [], llm_context: {}, thinking: nil, err: $stderr)
         sd = state_dir || Session.default_state_dir
         warn_memory_flags_ignored(attach || resume, memories, muted_memories, err) if attach || resume
         if attach
@@ -127,7 +132,8 @@ module Samagotchi
                   else
                     SessionManager.spawn_session(prompt: nil, model_name: model && model_ref(model), state_dir: sd,
                                                  memories: memories, muted_memories: muted_memories,
-                                                 llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context))
+                                                 setup: SessionSetup.new(llm_context: llm_context.empty? ? nil : LLMContextOverride.update(nil, llm_context),
+                                                                         thinking: Thinking.session_level(thinking)))
                   end
         client = BridgeClient.wait_for(session.id, session_dir: Session.session_dir(session.id, state_dir: sd), timeout: wait)
         client || raise(Error, "the worker for session #{session.id} did not start its Bridge in time")

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -14,6 +14,7 @@ require_relative "reline_seam"
 require_relative "version_lines"
 require_relative "../bridge/turn_accumulator"
 require_relative "../bridge_client"
+require_relative "../delivery"
 require_relative "../log"
 require_relative "../context_note"
 require_relative "../steer"
@@ -380,6 +381,14 @@ module Samagotchi
           return answer_question(text)
         end
 
+        # /cut TEXT and /queue TEXT are this UI's own deliveries, read before
+        # every command check (SessionCommands registers them for Tab and
+        # /help only). A plain line sends no delivery: it goes in at the
+        # running turn's next step, and never cuts.
+        if (choice = steer_choice(text))
+          return submit_delivery(*choice)
+        end
+
         # The terminal's own commands (SessionCommands registers them, the
         # REPL reads the same words). Before the continue offer: the
         # leaving ones are no answer to it.
@@ -414,6 +423,20 @@ module Samagotchi
         nil
       end
 
+      # /cut TEXT and /queue TEXT while a turn runs. Only /cut goes in P1:
+      # the worker's drain doesn't skip queued files yet, so a queued
+      # message would steer the running turn; /queue says so and sends
+      # nothing. At the prompt both run the text as a normal turn.
+      # @return [nil]
+      def submit_delivery(choice, text)
+        return @screen.commit(STEER_CHOICE_USAGE) if text.empty?
+        return @screen.commit(QUEUE_UNAVAILABLE) if choice == :queue && @running
+
+        # To an idle session it is an ordinary prompt: no delivery to send.
+        send_prompt(text, delivery: @running ? Delivery::CUT : nil)
+        nil
+      end
+
       # @return [Symbol] :detach
       def detach(line)
         @view.finish_thinking_spinner
@@ -573,6 +596,9 @@ module Samagotchi
       end
 
       QUEUED_NOTE = "(queued: runs after this turn)"
+      # /queue needs a worker whose drain skips queued input files (P3):
+      # until then a queued message would steer the running turn.
+      QUEUE_UNAVAILABLE = "(/queue isn't available in an attached session yet)"
 
       # A command queued for after the running turn (command_queued with
       # waits): its line now (another client's) and a note; its command_ran
@@ -661,19 +687,40 @@ module Samagotchi
         end
       end
 
-      def send_prompt(text)
+      # What a prompt's 202 says became of it, or nil when there is nothing
+      # to say: the dim line both TUIs print for a delivery. A plain line
+      # for a running turn goes in at its next step; a cut's outcome comes
+      # from the ack (the worker knows whether cutting is on for its model).
+      # An idle session's prompt simply runs, and a prompt with images runs
+      # as its own next turn (never merging mid-turn), so nothing is said.
+      # @param ack [Hash, nil] the Bridge's 202 body
+      # @param delivery [String, nil] what was asked for
+      # @return [String, nil]
+      def sent_note(ack, delivery: nil, images: [], running: false)
+        return nil unless running && images.empty? && ack.is_a?(Hash)
+
+        return NEXT_STEP_NOTE unless delivery == Delivery::CUT
+
+        steer_cut_note(ack["cut"].to_s.to_sym)
+      end
+
+      def send_prompt(text, delivery: nil)
         persist_recent_history(text)
         images = attach_images(text)
         return own_prompt_failed if images.nil?
 
+        running = @running
         options = { prompt: text, client_id: @client_id }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
+        options[:delivery] = delivery if delivery
         reply = @client.post_turn(**options)
         if reply.status == 202
           enqueued_id = reply.json&.fetch("enqueued_id", nil)
           @sent_ids << enqueued_id if enqueued_id
           @open_ids << enqueued_id if enqueued_id && @wait_at_eof
+          note = sent_note(reply.json, delivery: delivery, images: images, running: running)
+          @screen.commit(note) if note
           return
         end