samagotchi 0.10.1 → 0.12.0

data/lib/samagotchi/terminal_ui/reline_history_hook.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "reline"
+
+require_relative "line_reader"
+
+module Samagotchi
+  class TerminalUI
+    # Prepended to Reline::LineEditor: the first ↑ of a history walk at the
+    # main prompt runs the refresh first, so lines other processes (the web,
+    # another TUI) added to the shared history since the prompt opened are
+    # in the ring it walks. Set per read with .with_refresh; any other read
+    # (a question, a continue prompt) gets Reline's own ↑.
+    #
+    # Kept apart from RelineSeam, whose supported? is all-or-nothing: drift
+    # here only turns this hook off. It overrides two private methods of
+    # reline 0.6.x (the Gemfile pins it), both with Reline's signature
+    # (key, arg: 1), which Reline's dispatch looks at for an arg: keyword:
+    # - ed_prev_history: ↑, Ctrl-P, vi command k and -.
+    # - previous_history: its alias, which inputrc's previous-history binds.
+    # It reads two ivars: @history_pointer (nil while not walking the
+    # history) and @line_index (the cursor's line in a multi-line buffer;
+    # ↑ off line 0 only moves up a line). Without them it is plain Reline.
+    # A failing refresh leaves plain ↑; LineReader's Reprompt and Stop go on.
+    module RelineHistoryHook
+      # Reline's methods the hook overrides, with their arities.
+      METHODS = { ed_prev_history: -2, previous_history: -2 }.freeze
+
+      class << self
+        # @return [Boolean] this Reline has every method the hook overrides
+        def supported?
+          METHODS.all? { |name, arity| reline_method(name)&.arity == arity }
+        end
+
+        def install
+          Reline::LineEditor.prepend(self) unless Reline::LineEditor.include?(self)
+        end
+
+        # Run a read (on this thread) whose first ↑ of a walk calls
+        # +refresh+ first.
+        # @param refresh [#call, nil]
+        def with_refresh(refresh)
+          was = Thread.current[:samagotchi_reline_history_refresh]
+          Thread.current[:samagotchi_reline_history_refresh] = refresh
+          yield
+        ensure
+          Thread.current[:samagotchi_reline_history_refresh] = was
+        end
+
+        # @return [#call, nil] the refresh of the read on this thread
+        def refresh = Thread.current[:samagotchi_reline_history_refresh]
+
+        private
+
+        # Reline's own implementation, past this module once it is prepended.
+        def reline_method(name)
+          method = Reline::LineEditor.instance_method(name)
+          method = method.super_method while method&.owner == self
+          method
+        rescue NameError
+          nil
+        end
+      end
+
+      private
+
+      def ed_prev_history(key, arg: 1)
+        refresh_history_before_walk
+        super
+      end
+
+      def previous_history(key, arg: 1)
+        refresh_history_before_walk
+        super
+      end
+
+      # Only at the start of a walk: appending to Reline::HISTORY mid-walk
+      # would shift what the pointer means.
+      def refresh_history_before_walk
+        refresh = RelineHistoryHook.refresh
+        return unless refresh
+        return unless instance_variable_defined?(:@history_pointer) && instance_variable_defined?(:@line_index)
+        return unless @history_pointer.nil? && @line_index.zero?
+
+        refresh.call
+      rescue LineReader::Reprompt, LineReader::Stop
+        raise
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/terminal_ui.rb

@@ -12,7 +12,6 @@ require_relative "context_note"
 require_relative "cancellation_controller"
 require_relative "llm/errors"
 require_relative "host_registry"
-require_relative "kernel_loop"
 require_relative "session"
 require_relative "owner_lock"
 require_relative "engine"
@@ -84,8 +83,8 @@ module Samagotchi
       @scratch        = scratch
       @prompt         = prompt
       @default_model_name = ModelProfile.required_model_name(nil)
-      aliased_model_name = model_name.to_s.strip.empty? ? nil : ConfigFile.resolve_model_alias(model_name)
-      flag_model_name = aliased_model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(aliased_model_name)
+      # As typed: the Engine applies an alias where it resolves the model.
+      flag_model_name = model_name.to_s.strip.empty? ? nil : ModelProfile.required_model_name(model_name)
       @effective_model_name = flag_model_name || @default_model_name
       @host_registry  = host_registry || Samagotchi::HostRegistry.new
       # An injected client (specs) stands in for every host's client.
@@ -106,6 +105,7 @@ module Samagotchi
           @effective_model_name = flag_model_name
         else
           @effective_model_name = @resume_session.model_name.to_s.strip.empty? ? @default_model_name : @resume_session.model_name
+          @resumed_model_typed = @resume_session.model_typed
         end
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
@@ -113,9 +113,6 @@ module Samagotchi
       # The model it starts on names a configured host (a bad default.model
       # doesn't matter when --model or the session picks another).
       ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
-      # Only a caller's profile goes in; otherwise the Engine resolves one
-      # for the effective model and hands it to the kernel.
-      @kernel         = KernelLoop.new(client: @client, profile: profile, no_interrupt: no_interrupt, reminder_store: Samagotchi::ReminderStore.new)
       @no_default_input = no_default_input
       @non_interactive = non_interactive
       # --memory and --mute, with a resumed session's own lists first: a
@@ -156,7 +153,6 @@ module Samagotchi
         model_name: nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
-        kernel: @kernel,
         recap: scratch ? nil : recap_config,
         scratch: scratch,
         reminders: {
@@ -180,7 +176,7 @@ module Samagotchi
                                       registry: @engine.command_registry)
       # Runtime --model flag or resumed session: switch the Engine (client,
       # kernel profile) without persisting the default.
-      @engine.switch_model!(@effective_model_name) if @effective_model_name != @default_model_name
+      @engine.switch_model!(@effective_model_name, typed: @resumed_model_typed) if @effective_model_name != @default_model_name
       # Render an idle session-recap via the cursor-safe background writer; the
       # detector itself is Engine-owned (see Engine#recap) and opt-in.
       @recap_handle = @engine.subscribe(observer: ->(event) { @between_turns.take_recap(event) })
@@ -217,14 +213,14 @@ module Samagotchi
       # nothing and return (no transient session, no banner).
       return if @non_interactive && @prompt.nil?
 
-      session = @resume_session || Session.new_session(
+      session = @resume_session || @engine.store_model!(Session.new_session(
         mode: "assist",
         model_name: @effective_model_name,
         working_directory: Dir.pwd,
         preloaded_memory_names: @requested_memories,
         muted_memory_names: @muted_memory_names,
         scratch: @scratch
-      )
+      ))
       claim_session!(session.id) unless @owner_lock
       # Saved at once, so a process killed before its first turn leaves a
       # file the sweep knows to delete.
@@ -244,7 +240,9 @@ module Samagotchi
           cancel_controller: nil,
           images: ImageInput.extract(@prompt)
         )
-        if empty_answer?(result)
+        # No answer (the empty-answer retries used up): no text, or the chat
+        # loop's placeholder (LLM::ModelResult#empty_answer?).
+        if result.empty_answer?
           # Nothing to print: say so on stderr and fail, so a script that
           # pipes the answer doesn't take the silence for one.
           session.save
@@ -280,15 +278,6 @@ module Samagotchi
 
     EMPTY_ANSWER_ERROR = "chi: the model gave an empty answer"
 
-    # A -p --non-interactive turn that ended with no answer (the empty-answer
-    # retries used up): no text, or the chat loop's placeholder.
-    def empty_answer?(result)
-      return false if result.respond_to?(:canceled?) && result.canceled?
-      return false if result.respond_to?(:resumable?) && result.resumable?
-
-      result.output.to_s.strip.empty? || (result.respond_to?(:empty_answer?) && result.empty_answer?)
-    end
-
     # Delete the scratch session, the last thing the REPL does. Quiet after
     # a one-shot or on the way out of an error or a signal.
     def delete_scratch(session, quiet:)
@@ -668,7 +657,7 @@ module Samagotchi
     # After a prompt or continue turn: TurnFlow keeps the checkpoint and the
     # continue offer; the REPL saves and tells the user.
     def finish_turn(session, result, continue:)
-      if result.respond_to?(:canceled?) && result.canceled?
+      if result.canceled?
         outcome = @turn_flow.after_turn(result, continue: continue)
         # A cancelled continue is back where it started, the offer still open.
         return if outcome == :continue_cancelled
@@ -679,7 +668,7 @@ module Samagotchi
         # user's next message continues from it. !rollback restores the
         # pre-turn checkpoint for an explicit full discard (the renderer's
         # hint under :turn_canceled says so).
-        save_session(session) if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
+        save_session(session) if result.conversation.is_a?(Array)
         return
       end
 
@@ -691,7 +680,7 @@ module Samagotchi
     end
 
     def save_session(session)
-      session.model_name = @effective_model_name
+      @engine.store_model!(session)
       session.save
     end
 
@@ -757,10 +746,10 @@ module Samagotchi
       ensure
         @surface.clear_slot(:hints)
       end
-      canceled = result.respond_to?(:canceled?) && result.canceled?
+      canceled = result&.canceled?
       if result && !canceled
-        session.messages = result.conversation if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
-        session.model_name = @effective_model_name
+        session.messages = result.conversation if result.conversation.is_a?(Array)
+        @engine.store_model!(session)
         session.save
       end
       # The synthetic turn is activity: the next reminder waits a full
@@ -995,15 +984,7 @@ module Samagotchi
     end
 
     def cancelled_result_from(messages, reason:)
-      KernelLoop::Result.new(
-        output: "",
-        conversation: clone_messages(messages),
-        exhausted: false,
-        pending_tool_calls: false,
-        tool_activity: [],
-        canceled: true,
-        cancellation_reason: reason
-      )
+      LLM::ModelResult.new(text: "", conversation: clone_messages(messages), canceled: true, cancellation_reason: reason)
     end
 
     # The status row under the prompt, from the Engine's state (what a

data/lib/samagotchi/thinking.rb

@@ -65,7 +65,7 @@ module Samagotchi
       key, value = ConfigFile.model_setting(names, :thinking, models: models)
       return [value, "models: #{key}"] if key
 
-      host = target.entry.respond_to?(:thinking) ? target.entry.thinking : nil
+      host = target.entry.thinking
       return [host, "hosts.#{target.entry.name}"] if host
       return [global, "thinking.level"] if global
 

data/lib/samagotchi/tool_response.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A tool batch and the conversation entries its results become, for both
+  # loops. The calls run through ToolRunner between the dispatch events;
+  # what the model gets back is per format: the native loop answers a batch
+  # with ONE tool_response (#joined: the full outputs), the chat loop each
+  # call with its own, paired by tool_call_id (#single: the capped output,
+  # D-P2-6).
+  module ToolResponse
+    SEPARATOR = "\n\n---\n\n"
+    # Saved with a result for the web's reload (a plugin tool's params line
+    # and label, an edit/write's diff); the prompt never reads them.
+    SAVED_KEYS = %i[tool_params tool_labels tool_diffs].freeze
+
+    module_function
+
+    # Runs +calls+ in order (ToolRunner#run each), yielding each run and its
+    # index as it finishes. +emit+ takes the dispatch events, the runner's
+    # own go to +on_stream_event+.
+    # @return [Array<Hash>] the runs
+    def run_batch(runner, calls, iteration:, emit:, on_stream_event:, cap:)
+      emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
+      runs = calls.each_with_index.map do |call, index|
+        run = runner.run(call, iteration: iteration, call_index: index + 1, call_count: calls.length,
+                               on_stream_event: on_stream_event, max_tool_output_chars: cap)
+        yield run, index if block_given?
+        run
+      end
+      emit.call({ type: :tool_dispatch_completed, iteration: iteration, call_count: calls.length })
+      runs
+    end
+
+    # The runs' activity, for the turn's tool list (none for a call whose
+    # dispatcher raised).
+    def activities(runs)
+      runs.filter_map { |run| run[:activity] }
+    end
+
+    # The native loop's entry for a batch: the outputs joined, every image
+    # in call order with how many each call returned (the web's reload puts
+    # each on its own tool row), and the saved-only fields one per call.
+    def joined(runs)
+      images = runs.flat_map { |run| Array(run[:images]) }
+      entry = { role: "tool_response", content: runs.map { |run| run[:output] }.join(SEPARATOR) }
+      unless images.empty?
+        entry[:images] = images
+        entry[:image_counts] = runs.map { |run| Array(run[:images]).size }
+      end
+      saved = { tool_params: runs.map { |run| run[:shown_params] }, tool_labels: runs.map { |run| run[:shown_label] },
+                tool_diffs: runs.map { |run| run[:diff] } }
+      saved.each { |key, values| entry[key] = values if values.any? }
+      entry
+    end
+
+    # The chat loop's entry for one call: its capped output, paired with the
+    # call by +tool_call_id+.
+    def single(run, tool_call_id:)
+      entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call_id }
+      entry[:images] = run[:images] if run[:images]&.any?
+      entry[:tool_params] = run[:shown_params] if run[:shown_params]
+      entry[:tool_labels] = run[:shown_label] if run[:shown_label]
+      entry[:tool_diffs] = run[:diff] if run[:diff]
+      entry
+    end
+  end
+end

data/lib/samagotchi/tool_runner.rb

@@ -80,7 +80,12 @@ module Samagotchi
         capped = output[0, max_tool_output_chars]
       end
 
-      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped })
+      # The call's outcome as its activity line has it (worked out from the
+      # full output: ok, error, blocked, stopped); a dispatcher that raised
+      # left none, an error.
+      status = result[:activity].is_a?(Hash) ? result[:activity][:status] : nil
+      fire(:after_tool_call, { type: :after_tool_call, iteration: iteration, tool: call[:name], output: capped,
+                               status: status || "error" })
       completed = { type: :tool_call_completed, iteration: iteration, call_count: call_count, call_index: call_index,
                     tool: call[:name], output: capped, output_truncated: truncated, activity: result[:activity] }
       completed[:images] = images if images&.any?
@@ -141,7 +146,7 @@ module Samagotchi
     # says the image is attached, that line replaces the text.
     # @return [Array(Hash, Array<Hash>)] the result and its refs
     def attach_images(call, result)
-      vision = @kernel.vision if @kernel.respond_to?(:vision)
+      vision = @kernel.turn_settings.vision
       reason = if vision.nil? then "images can't be attached here"
                elsif !vision.sendable? then ImagePlan::CANT_SEE
                end
@@ -187,7 +192,7 @@ module Samagotchi
     end
 
     # The kernel's tools, for the activity line of a tool that isn't built in.
-    def tools = @kernel.respond_to?(:tools) ? @kernel.tools : nil
+    def tools = @kernel.tools
 
     # A tool the registry has from a plugin (not core, not unknown).
     def plugin_tool?(name)
@@ -201,8 +206,7 @@ module Samagotchi
     # The Engine sets the kernel's gate (its context, later the approval
     # flow); a bare kernel (specs) gets one that only runs the hooks.
     def gate
-      given = @kernel.guardrail_gate if @kernel.respond_to?(:guardrail_gate)
-      given || (@gate ||= Guardrails::Gate.new(-> { @kernel.hooks if @kernel.respond_to?(:hooks) }, tools_lookup: -> { tools }))
+      @kernel.guardrail_gate || (@gate ||= Guardrails::Gate.new(-> { @kernel.hooks }, tools_lookup: -> { tools }))
     end
 
     # A gate that fails denies the call (fail closed).
@@ -249,8 +253,7 @@ module Samagotchi
 
     # A failing hook must not break the turn.
     def fire(name, event)
-      hooks = @kernel.hooks if @kernel.respond_to?(:hooks)
-      hooks&.fire(name, event)
+      @kernel.hooks&.fire(name, event)
     rescue StandardError
       nil
     end

data/lib/samagotchi/tools/builtins.rb

@@ -103,7 +103,7 @@ module Samagotchi
       # (as DelegateWait does); a bare kernel has no peers: never cancelled.
       def cancelled_proc(kctx)
         peers = kctx.peers
-        -> { peers.respond_to?(:cancelled?) && peers.cancelled? }
+        -> { !!peers&.cancelled? }
       end
 
       # @return [Registry] a new registry with the built-ins, in

data/lib/samagotchi/tools/delegate.rb

@@ -117,12 +117,13 @@ module Samagotchi
       end
       private_class_method :follow_up
 
-      # --model as the REPL reads it: an alias resolved, a host prefix kept.
-      # No existence check: an unknown model fails the child's first turn.
+      # The model as typed (spawn_session stores its resolved ref), else the
+      # parent's. No existence check: an unknown model fails the child's
+      # first turn.
       def self.child_model(model, parent)
         return parent.model_name if model.to_s.strip.empty?
 
-        ModelProfile.required_model_name(ConfigFile.resolve_model_alias(model.to_s.strip))
+        ModelProfile.required_model_name(model.to_s.strip)
       end
       private_class_method :child_model
 

data/lib/samagotchi/tools/delegate_wait.rb

@@ -43,7 +43,7 @@ module Samagotchi
       def call(child_id, peers:, timeout: TIMEOUT_DEFAULT, poll_interval: POLL_INTERVAL)
         sd = peers.state_dir || Session.default_state_dir
         key = [peers.session_id, child_id]
-        cancelled = -> { peers.respond_to?(:cancelled?) && peers.cancelled? }
+        cancelled = -> { peers.cancelled? }
         wait = ReplyWait.call(child_id, state_dir: sd, cursor: seen[key], timeout: timeout.to_i,
                                         poll_interval: poll_interval, cancelled: cancelled, baseline: baselines[key])
         # The turn sent to is handed over: a later wait looks for a later one.

data/lib/samagotchi/tools/memory.rb

@@ -22,7 +22,8 @@ module Samagotchi
 
       SEPARATOR = "\n\n---\n\n"
 
-      def self.call(entry_name, scope: nil, model_key: nil)
+      # @param fallback_model_key [String, nil] read when +model_key+ has no overlay
+      def self.call(entry_name, scope: nil, model_key: nil, fallback_model_key: nil)
         entry_name = entry_name.to_s.strip
         scope = normalize_scope(scope)
 
@@ -60,11 +61,12 @@ module Samagotchi
             if File.exist?(path)
               body = File.read(path)
               # Append model-specific overlay if key is provided and overlay exists.
-              if model_key
-                overlay_path = ModelOverlay.overlay_path_for(name, model_key, resolved_scope)
-                if overlay_path && File.exist?(overlay_path)
-                  body += SEPARATOR + "Model-specific guidance (#{model_key}):\n" + File.read(overlay_path)
-                end
+              [model_key, fallback_model_key].compact.each do |key|
+                overlay_path = ModelOverlay.overlay_path_for(name, key, resolved_scope)
+                next unless overlay_path && File.exist?(overlay_path)
+
+                body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path)
+                break
               end
               results << body
               found = true

data/lib/samagotchi/turn_flow.rb

@@ -72,7 +72,7 @@ module Samagotchi
     #   turn: its partial progress stays, !rollback can undo it) or
     #   :continue_cancelled (back to before the continue; the offer stays)
     def after_turn(result, continue: false, no_interrupt: false)
-      if result.respond_to?(:canceled?) && result.canceled?
+      if result.canceled?
         if continue
           restore(@continue_checkpoint)
           return :continue_cancelled
@@ -85,7 +85,7 @@ module Samagotchi
         return :cancelled
       end
 
-      if result.respond_to?(:resumable?) && result.resumable?
+      if result.resumable?
         @offer = { context: interrupted_turn_context(result), no_interrupt: no_interrupt }
         :continue_offered
       else
@@ -172,7 +172,7 @@ module Samagotchi
     end
 
     def conversation_of(result)
-      result.conversation if result.respond_to?(:conversation) && result.conversation.is_a?(Array)
+      result.conversation if result.conversation.is_a?(Array)
     end
 
     def interrupted_turn_context(result)
@@ -198,7 +198,7 @@ module Samagotchi
     end
 
     def tool_trace(result)
-      activities = result.respond_to?(:tool_activity) ? Array(result.tool_activity) : []
+      activities = Array(result.tool_activity)
       activities.last(SUMMARY_TOOLS_LIMIT).map do |activity|
         tool = activity[:tool].to_s.strip
         status = activity[:status].to_s.strip

data/lib/samagotchi/turn_state.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Samagotchi
+  # A session's turn as other threads see it: whether one runs, its cancel
+  # controller and event sink, the plugin steers waiting for its next
+  # boundary, and the activity clock the idle jobs read.
+  #
+  # The turn thread writes it (Engine#begin_turn, #release_turn); the idle
+  # scheduler, the bridge's request threads, plugin threads and the UIs
+  # read it. The lock is a leaf: nothing is called out while it is held,
+  # so any lock may be held around a call into it, and it is never held
+  # around anything else.
+  class TurnState
+    # @param clock [#call] monotonic seconds
+    def initialize(clock:)
+      @clock = clock
+      @lock = Monitor.new
+      @last_activity_at = clock.call
+      @activity_seq = 0
+      @running = false
+      @controller = nil
+      @sink = nil
+      @steers = []
+    end
+
+    # ── Activity clock ──────────────────────────────────────────────────
+
+    # Activity happened (user input, a finished turn): the clock moves to
+    # +now+ and the sequence advances, so the idle jobs re-arm.
+    # @param now [Float, nil] monotonic seconds; the clock's now by default
+    def record_activity(now = nil)
+      now = now ? now.to_f : @clock.call
+      @lock.synchronize do
+        @last_activity_at = now
+        @activity_seq += 1
+      end
+    end
+
+    # Start the idle window now without counting it as activity (the
+    # sequence stays): the Engine does once its plugins have loaded, so a
+    # slow plugin start doesn't shorten the first window.
+    def restart_clock!
+      now = @clock.call
+      @lock.synchronize { @last_activity_at = now }
+    end
+
+    # @return [Float] monotonic seconds of the last activity
+    def last_activity_at
+      @lock.synchronize { @last_activity_at }
+    end
+
+    # @return [Integer] how many times activity was recorded
+    def activity_seq
+      @lock.synchronize { @activity_seq }
+    end
+
+    # ── The turn ────────────────────────────────────────────────────────
+
+    # @return [Boolean] whether a turn runs
+    def running?
+      @lock.synchronize { @running }
+    end
+
+    # A turn begins: running, with its controller and sink, in one step.
+    def begin!(controller:, sink:)
+      @lock.synchronize do
+        @running = true
+        @controller = controller
+        @sink = sink
+      end
+    end
+
+    # The turn is over: not running, no controller, sink or steers.
+    # @return [Array<Hash>] the steers it never took ({text:, source:})
+    def finish!
+      @lock.synchronize do
+        @running = false
+        @controller = nil
+        @sink = nil
+        @steers.tap { @steers = [] }
+      end
+    end
+
+    # @return [CancellationController, nil] the running turn's controller
+    def controller
+      @lock.synchronize { @controller }
+    end
+
+    # Cancel the running turn, if any (outside the lock).
+    # @return [Boolean] whether a cancellation was triggered
+    def cancel!(reason)
+      ctrl = controller
+      return false unless ctrl
+
+      ctrl.cancel!(reason)
+    end
+
+    # @return [Array(Boolean, #call)] whether a turn runs, and its sink
+    def in_turn_sink
+      @lock.synchronize { [@running, @sink] }
+    end
+
+    # ── Steers ──────────────────────────────────────────────────────────
+
+    # Queue +text+ for the running turn's next boundary.
+    # @return [Boolean] whether it was queued (false: blank, or no turn)
+    def steer(text, source:)
+      text = text.to_s.strip
+      return false if text.empty?
+
+      @lock.synchronize do
+        return false unless @running
+
+        @steers << { text: text, source: source.to_s }
+      end
+      true
+    end
+
+    # @return [Array<Hash>] the steers queued so far ({text:, source:}), taken
+    def take_steers
+      @lock.synchronize { @steers.tap { @steers = [] } }
+    end
+  end
+end