samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/terminal_ui/join_replay.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../bridge/turn_accumulator"
+require_relative "../bridge/turn_drawings"
 require_relative "../context_note"
 require_relative "../image_store"
 require_relative "../log"
@@ -31,11 +33,32 @@ module Samagotchi
         @renderer = renderer
       end
 
+      # A snapshot's last_turn_drawing (Bridge#snapshot: the last exchange's
+      # turn as live drew it) draws that turn's rows; without one (an older
+      # worker, a turn before drawings) they are rebuilt from the messages.
       def render_join(snapshot, saved)
-        render_join_header(Array(snapshot[:messages]))
+        render_join_header(Array(snapshot[:messages]), drawing: snapshot[:last_turn_drawing])
         render_join_gap(snapshot, saved)
       end
 
+      # One replayed event of a turn's rows (TurnAccumulator.replay_events),
+      # as live drew it: a joined running turn's (AttachedLoop#render_current_turn)
+      # and a drawn finished one's (#render_drawn_turn). Its tool rows with
+      # their action and duration, merged input, reminders, a plugin's steer,
+      # a hook's notice, a retry's, a steer cut's and a ✂ row's line. The
+      # step text, the turn's start and questions are the caller's (the
+      # pending one is asked after the replay, answered ones showed no line).
+      def replay_row(event)
+        case event[:type]
+        when :tool_call_started then @renderer.call(event)
+        when :tool_call_completed then replay_tool_completed(event)
+        when :merged_input then @screen.commit("input> #{event[:content]}")
+        when :reminder_injected then @screen.commit(reminder_line(event[:reminders]))
+        when :pending_input_merged, :hook_notice, :empty_answer_retry, :steer_cut, :llm_context_edited
+          @renderer.call(event)
+        end
+      end
+
       # The snapshot's cards and between-turns notices (Bridge CardStore):
       # on join the ones since the last turn (and the running turn's), as
       # the join header shows the last exchange; on a resync only cards not
@@ -60,6 +83,18 @@ module Samagotchi
 
       private
 
+      # A finished tool call: the live row (action, duration: none when the
+      # part has none, never the replay's own clock). A snapshot from an
+      # older worker has no action: its row names the tool only.
+      def replay_tool_completed(event)
+        return @renderer.call({ duration_ms: nil }.merge(event)) if event.dig(:activity, :action)
+
+        activity = EventRenderer.described(event) || {}
+        @screen.commit(snapshot_tool_line({ tool: event[:tool], params: activity[:params], status: activity[:status],
+                                            description: activity[:description], output_truncated: event[:output_truncated],
+                                            images: event[:images], diff: event[:diff] }))
+      end
+
       # Where the session's last activity was: its newest stamped entry,
       # else its saved recap's time. A gap ago (and no turn running): one
       # line after the join block says when.
@@ -71,7 +106,7 @@ module Samagotchi
         @screen.commit(gap_divider(line)) if line
       end
 
-      def render_join_header(messages)
+      def render_join_header(messages, drawing: nil)
         exchange = messages.select { |m| %w[user model assistant].include?(m[:role].to_s) }
         # The id stays findable: the detach line and chi sessions list show it.
         Log.session_id = @link.client.session_id
@@ -89,6 +124,11 @@ module Samagotchi
         unless ImageRef.placeholder_only?(exchange[last_user][:content])
           Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
         end
+        if (drawn = drawn_turn(drawing, exchange[last_user]))
+          render_drawn_turn(*drawn, exchange[(last_user + 1)..])
+          return render_join_notes(messages, from, after_exchange: true)
+        end
+
         render_join_steps(messages, from, durations: join_tool_records(exchange[last_user]))
         record = @link.saved_turn_record(exchange[last_user][:turn_id] || exchange[last_user]["turn_id"])
         failed = join_failed_record(record)
@@ -109,16 +149,59 @@ module Samagotchi
           @screen.commit(@view.turn_canceled_line(record["cancellation_reason"], record["duration_ms"], by: record["cancelled_by"]))
           @screen.commit(@view.turn_end_hint(ROLLBACK_HINT)) unless record["continue"]
         else
-          # The saved answer is raw: the latest keeps its thinking, and one may
-          # be only a tool call.
-          answer = exchange[(last_user + 1)..].reverse_each
-                                             .map { |m| OutputFormatter.strip_markup(m[:content]) }
-                                             .find { |text| !text.empty? }
-          @screen.commit(last_lines(answer)) if answer
+          render_join_answer(exchange[(last_user + 1)..])
         end
         render_join_notes(messages, from, after_exchange: true)
       end
 
+      # The last answer of the messages after the prompt (+after+). The saved
+      # answer is raw: the latest keeps its thinking, and one may be only a
+      # tool call.
+      def render_join_answer(after)
+        answer = after.reverse_each.map { |m| OutputFormatter.strip_markup(m[:content]) }.find { |text| !text.empty? }
+        @screen.commit(last_lines(answer)) if answer
+      end
+
+      # The snapshot's drawing as [turn, end event] when it is +prompt+'s
+      # turn (a Continue's or a reminder's drawing isn't the prompt's: the
+      # rows are rebuilt), else nil; nil too for one whose parts aren't a
+      # list of rows.
+      def drawn_turn(drawing, prompt)
+        return nil unless drawing.is_a?(Hash) && drawing[:drawing].is_a?(Hash) && drawing[:end].is_a?(Hash)
+
+        turn = Bridge::TurnAccumulator.from_wire(drawing[:drawing])
+        id = prompt[:turn_id] || prompt["turn_id"]
+        return nil unless id && turn[:turn_id].to_s == id.to_s
+        # An older worker sends a line its parse didn't check (the unfold
+        # would raise after the prompt line is drawn).
+        return nil unless Bridge::TurnDrawings.rows?(turn[:parts])
+
+        [turn, EventRenderer.symbolize(Bridge::TurnAccumulator.from_wire(drawing[:end]))]
+      end
+
+      # The last turn from its drawing, through the renderer as live drew it
+      # (the running turn's join path, AttachedLoop#render_current_turn): its
+      # rows with their status and duration, a retry's line, a hook's notice,
+      # steers, merged input and reminders; no step text (the live ticker's)
+      # and no cards (the snapshot's cards are drawn after). Then its end: a
+      # cancel's or a failure's line from the end event, else the empty
+      # answer's notice or the saved answer (+after+, the messages after the
+      # prompt).
+      def render_drawn_turn(turn, ending, after)
+        Bridge::TurnAccumulator.replay_events(turn).each do |event|
+          # The prompt line named its images already.
+          event[:type] == :turn_started ? @renderer.call(event.except(:images)) : replay_row(event)
+        end
+        case ending[:type]
+        when :turn_canceled, :turn_failed then @renderer.call(ending)
+        else
+          empty = ending.dig(:turn_summary, :empty_answer)
+          empty ? @screen.commit(format_empty_answer_line(empty[:retries], empty[:refusal])) : render_join_answer(after)
+        end
+        # A call the turn never answered left the tool slot running.
+        @view.finish_thinking_spinner
+      end
+
       # What the last exchange did, as the live turn drew it: each saved
       # call's tool row (action, params, status from its result, and its
       # duration from +durations+, the turn's saved tool records) and a

data/lib/samagotchi/terminal_ui/local_link.rb

@@ -112,13 +112,13 @@ module Samagotchi
       # no turn id (an older session) or a session with no analytics.
       def saved_tool_records(turn_id)
         SessionMetrics.saved_tool_records(session_dir, turn_id)
-      rescue Session::InvalidId
+      rescue SessionPaths::InvalidId
         []
       end
 
       def saved_turn_record(turn_id)
         SessionMetrics.saved_turn_record(session_dir, turn_id)
-      rescue Session::InvalidId
+      rescue SessionPaths::InvalidId
         nil
       end
 

data/lib/samagotchi/terminal_ui.rb

@@ -90,7 +90,9 @@ module Samagotchi
       # 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
+      # Taken once (as the Engine's); a client (specs) goes on a registry of
+      # its own, never the shared one.
+      @host_registry = host_registry || (client ? Samagotchi::HostRegistry.new : Samagotchi::HostRegistry.current)
       # An injected client (specs) stands in for every host's client.
       @host_registry.client_override = client if client
       @client = @host_registry.resolve(@effective_model_name).client

data/lib/samagotchi/testing/bundle.rb

@@ -25,7 +25,7 @@ require_relative "recording_api"
 
 module Samagotchi
   module Testing
-    # A hook (a plugin's chi.on block or a hook file) raised while the kit
+    # A hook (a plugin's chi.on block) raised while the kit
     # fired it: chi would log it and go on, a test fails with it.
     class HookFailed < StandardError
       # @return [Hooks::Failure]
@@ -53,8 +53,7 @@ module Samagotchi
 
     # One bundle loaded for a test through chi's own seams: its plugin
     # through Plugin::Loader.register_file (Plugin::Api, a real
-    # Plugin::Context) and its hook files through
-    # Hooks::BundleLoader.load_hook_file, into real registries (commands
+    # Plugin::Context), into real registries (commands
     # and tools with chi's built-ins in them, so a name clash fails as in
     # chi). Only the edges are recorded: the Host and hook Runtime
     # (Recorder), ctx.sessions (Testing::Sessions), chi.init tasks and
@@ -130,8 +129,6 @@ module Samagotchi
       # @return [Module, nil] the module the plugin was evaluated in
       #   (bundle.namespace::ThinkingWatch)
       attr_reader :namespace
-      # @return [Module] the module the hook files were evaluated in
-      attr_reader :hooks_namespace
       # @return [Array<Init>]
       attr_reader :inits
       # @return [Array<StagedTools>]
@@ -152,6 +149,9 @@ module Samagotchi
         @session_moves = 1
         own = session_settings.nil? || session_settings.empty? ? {} : { setup: setup_with(session_settings, host[:setup]) }
         @own_sandbox = sandbox.nil? && Sandbox.current.nil?
+        # With no active sandbox, this one saves ENV at construction and
+        # restores that copy at shutdown; don't lazily build it inside a block
+        # that sets ENV for one example (your own helper, or ClimateControl).
         @sandbox = sandbox || Sandbox.current || Sandbox.enter
         build(host, own)
       rescue Exception # rubocop:disable Lint/RescueException -- leave the sandbox it entered, whatever failed
@@ -184,13 +184,6 @@ module Samagotchi
             @plugin = built
           end
         end
-        @hooks_namespace = Module.new
-        @manifest.hooks.each do |basename, hook|
-          next if hook.events.empty?
-
-          Hooks::BundleLoader.load_hook_file(@name, basename, File.join(@dir, "hooks", basename), hook, hooks,
-                                             settings: @settings, namespace: @hooks_namespace)
-        end
         self
       rescue Exception # rubocop:disable Lint/RescueException -- leave the sandbox it entered, whatever failed
         shutdown

data/lib/samagotchi/testing/install.rb

@@ -15,7 +15,7 @@ module Samagotchi
     # A bundle as chi installs and loads it, unlike Bundle (its source as it
     # is): MemoryBundle::Installer copies it into the sandbox's state (sha256
     # and requires_chi checked), then chi's own loaders load what is
-    # installed (ExtensionLoad: the bundle hooks, then the plugins). What
+    # installed (ExtensionLoad: config hooks, then the plugins). What
     # failed names the bundle's source files, not the installed copies.
     #
     #   result = Samagotchi::Testing::Install.run("path/to/bundle", settings: { "every" => 3 })
@@ -23,7 +23,8 @@ module Samagotchi
     module Install
       # warnings: the Installer's; plugin_failures / hook_failures:
       # [Guardrails::LoadFailures::Failure] of this bundle, each location
-      # in the source dir; registered: what it registered (#registered).
+      # in the source dir (hook_failures: the guardrails': a required
+      # plugin's load failure, a config hook's); registered: what it registered (#registered).
       Result = Data.define(:name, :warnings, :plugin_failures, :hook_failures, :registered) do
         def failures = plugin_failures + hook_failures
       end
@@ -34,7 +35,7 @@ module Samagotchi
       Registered = Data.define(:commands, :tools, :hooks, :inits, :toolkits, :tool_sources, :peer_sources, :prompt_sections)
       # A command: its mid_turn policy and its selection-bar labels (chi.annotation).
       Command = Data.define(:name, :mid_turn, :labels)
-      # A hook on an event: the bundle, the hook (its file, or the plugin's) and its priority.
+      # A hook on an event: the bundle, the hook (the plugin's label) and its priority.
       Hook = Data.define(:bundle, :hook, :priority)
 
       module_function
@@ -118,7 +119,7 @@ module Samagotchi
       # installed copy to the source dir.
       def own(failures, name, installed, dir)
         failures.list.select { |f| f.what.end_with?("(bundle #{name})") }.map do |failure|
-          # The plugin is installed into plugin/, the hooks into hooks/.
+          # The plugin is installed into plugin/.
           location = failure.location&.sub(%r{\A#{Regexp.escape(installed)}/(?:plugin/)?}, "#{dir}/")
           failure.dup.tap { |copy| copy.location = location }
         end

data/lib/samagotchi/testing/recorder.rb

@@ -9,7 +9,7 @@ require_relative "judgments"
 module Samagotchi
   module Testing
     # A line to the user (ctx.notify, event[:notify]); +hook+ is the
-    # plugin's or hook file's label ("plugin.rb (bundle x)").
+    # plugin's label ("plugin.rb (bundle x)").
     Notice = Data.define(:text, :level, :hook, :fallback_for)
     # Text put into the running turn (ctx.steer, event[:steer]).
     Steer = Data.define(:text, :hook)

data/lib/samagotchi/testing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # The bundle test kit (docs/plugins.md, "Testing a bundle"): load a bundle's
-# plugin and hook files through chi's own loaders, registries, Context and
+# plugin through chi's own loaders, registries, Context and
 # guardrail Gate, with only the edges recorded (the session's Host, the hook
 # runtime, ctx.sessions, init tasks), in a sandboxed environment.
 #

data/lib/samagotchi/thinking.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "config"
-require_relative "model_profile"
 require_relative "setting_explained"
 
 module Samagotchi
@@ -79,30 +78,23 @@ module Samagotchi
       nil
     end
 
-    # The level for +target+ and where it came from ("session",
+    # The level for +lookup+'s model and where it came from ("session",
     # "--thinking", "models: qwen", "hosts.work", "thinking.level"; nil for
     # the default).
-    # @param target [HostRegistry::ModelTarget]
-    # @param names [Array<String>] the model's lookup names (HostRegistry#lookup_names)
-    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @param session [Symbol, nil] the session's own level (Session#thinking)
     # @return [Array(Symbol, String|nil)]
-    def resolve(target, names:, models: nil, session: nil)
+    def resolve(lookup, session: nil)
       return [session, SESSION_SOURCE] if session
 
-      global, origin = global_level
+      global, origin = global_level(lookup)
       return [global, origin == :cli ? "--thinking" : "SAMAGOTCHI_THINKING_LEVEL"] if global && %i[cli env].include?(origin)
 
-      models ||= begin
-        ModelSettings.all
-      rescue StandardError
-        {}
-      end
-      setting = ModelSettings.find(names, :thinking, models: models)
+      setting = lookup.model(:thinking)
       return [setting.value, "models: #{setting.key}"] if setting
 
-      host = target.entry.thinking
-      return [host, "hosts.#{target.entry.name}"] if host
+      host = lookup.host(:thinking)
+      return [host, "hosts.#{lookup.host_name}"] if host
       return [global, "thinking.level"] if global
 
       [DEFAULT, nil]
@@ -110,14 +102,15 @@ module Samagotchi
 
     # #resolve, as a SettingExplained with the session's own level beside it.
     # @return [SettingExplained]
-    def explain(target, names:, models: nil, session: nil)
-      level, source = resolve(target, names: names, models: models, session: session)
+    def explain(lookup, session: nil)
+      level, source = resolve(lookup, session: session)
       SettingExplained.new(level: level, source: source, own: session)
     end
 
     # thinking.level as a level and its origin (:cli, :env, :file), or nil.
-    def global_level
-      raw, origin = Config.get_with_origin("thinking.level")
+    # @param lookup [ModelLookup] whose env the key is read with
+    def global_level(lookup)
+      raw, origin = lookup.global("thinking.level")
       return nil if origin == :default
 
       where = { cli: "--thinking", env: "SAMAGOTCHI_THINKING_LEVEL" }.fetch(origin, "thinking.level")
@@ -139,13 +132,15 @@ module Samagotchi
     #              only the tail changes (llama.cpp and Splash keep the rest).
     # @param target [HostRegistry::ModelTarget]
     # @param profile [String, nil] the native prompt profile's name
+    # @param inferred [String, nil] the profile a local chat host's model
+    #   name says (ModelProfile.inferred_profile_name of its bare id)
     # @return [Symbol]
-    def cache_cost(target, profile: nil)
+    def cache_cost(target, profile: nil, inferred: nil)
       entry = target.entry
       if entry&.chat?
         return :provider if entry.remote?
 
-        return ModelProfile.inferred_profile_name(target.bare_model) == "gemma4" ? :full : :tail
+        return inferred == "gemma4" ? :full : :tail
       end
 
       profile == "gemma4" ? :full : :tail

data/lib/samagotchi/tool_declarations.rb

@@ -375,7 +375,7 @@ module Samagotchi
             },
             cwd: {
               type: "string",
-              description: "The new child's working folder: a worktree or subfolder of this session's repository (create a worktree with execute `git worktree add ../<repo>-<name> -b <branch>` first). Default: this session's folder"
+              description: "The new child's working folder: a worktree or subfolder of this session's project (a repository, or a `chi project init` folder; create a worktree with execute `git worktree add ../<repo>-<name> -b <branch>` first). Default: this session's folder"
             },
             toolkit: {
               type: "string",

data/lib/samagotchi/tool_response.rb

@@ -35,15 +35,17 @@ module Samagotchi
     # #interrupted run for every call left (the one it cut short too), so
     # the loop's conversation answers each call, then goes on up: the turn
     # keeps its progress (Engine#ctrl_c_messages). +context+: the calls'
-    # turn (TurnContext), each run's (ToolRunner#run).
+    # turn (TurnContext), each run's (ToolRunner#run). +ids+: the calls'
+    # ToolIds, in call order (ToolIds.next_ids before the batch: the ids the
+    # entries are saved under), each on its run's tool events; nil: none.
     # @return [Array<ToolRun>] the runs
-    def run_batch(runner, calls, context:, iteration:, emit:, on_stream_event:, cap:)
+    def run_batch(runner, calls, context:, iteration:, emit:, on_stream_event:, cap:, ids: nil)
       # Before anything can be interrupted: the rescue counts it.
       runs = []
       emit.call({ type: :tool_dispatch_started, iteration: iteration, call_count: calls.length })
       calls.each_with_index do |call, index|
         runs << runner.run(call, context: context, iteration: iteration, call_index: index + 1, call_count: calls.length,
-                                 on_stream_event: on_stream_event, max_tool_output_chars: cap)
+                                 on_stream_event: on_stream_event, max_tool_output_chars: cap, tool_id: ids&.[](index))
         yield runs.last, index if block_given?
       end
       emit.call({ type: :tool_dispatch_completed, iteration: iteration, call_count: calls.length })

data/lib/samagotchi/tool_runner.rb

@@ -86,7 +86,10 @@ module Samagotchi
     #   file (EditPreview.change; also on tool_call_completed, never in the
     #   model's output)
     # @param context [TurnContext] the call's turn
-    def run(call, context:, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:)
+    # @param tool_id [String, nil] the id the run's output is saved under
+    #   (ToolIds, handed out before the batch runs), on both tool events
+    #   so a UI's row and the saved output share it
+    def run(call, context:, iteration:, call_index:, call_count:, on_stream_event:, max_tool_output_chars:, tool_id: nil)
       # A call_tool of one of chi's own tools runs as that tool, from here
       # on (the gate, the row, the result): rules, approvals and hooks see
       # the real call, with via: (Tools::ToolIndex#unwrap).
@@ -114,6 +117,7 @@ module Samagotchi
       started = { type: :tool_call_started, iteration: iteration, call_count: call_count, call_index: call_index,
                   tool: call[:name], call: call.dup, params: params }
       started[:label] = label if label
+      started[:tool_id] = tool_id if tool_id
       # Its row fields (ToolRowFields: title, called_as, via, view, ref, and a
       # plugin tool's refs); the worker runs in its session's working
       # directory.
@@ -121,6 +125,8 @@ module Samagotchi
       refs = RowRefs.for(tools && !call[:name].nil? ? tools[call[:name]]&.refs : nil, call, cwd: session_cwd(context))
       fields[:refs] = refs unless refs.empty?
       started.merge!(fields)
+      # The row's clock: tool_call_completed's duration_ms runs from here.
+      started_clock = @clock.call
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
@@ -175,9 +181,20 @@ module Samagotchi
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
       completed[:output_file] = output_file if output_file
+      completed[:tool_id] = tool_id if tool_id
+      # A long output's web row (its hover): the cut a reload draws from the
+      # saved output (MessageParts#tool_part), so live and reload show the
+      # same text. The TUI keeps +output+.
+      if capped.length > ToolOutputCut::WEB_PREVIEW_CHARS
+        completed[:preview] = ToolOutputCut.preview(capped, cap: ToolOutputCut::WEB_PREVIEW_CHARS, tool: call[:name])
+      end
       # Also here: a UI that missed the start (a replay gap) builds its row
       # from this event (its title is in the activity).
       completed.merge!(fields.slice(*ToolRowFields::EVENT_KEYS))
+      # The row's duration, the one every UI shows (live, a reload's tool
+      # record, the attached terminal): SessionMetrics' definition and
+      # rounding order, from the started emit to this one, less the wait.
+      completed[:duration_ms] = [((@clock.call - started_clock) * 1000).round - (waited_ms || 0), 0].max
       emit(on_stream_event, completed)
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.

data/lib/samagotchi/toolkit_binding.rb

@@ -139,10 +139,7 @@ module Samagotchi
 
       toolkit = Toolkit.new(name: name)
       if session.toolkit == toolkit
-        if session.toolkit_origin != "chosen"
-          session.toolkit_origin = "chosen"
-          session.save(state_dir: @state_dir.call)
-        end
+        session.save(state_dir: @state_dir.call) if session.choose_toolkit_origin!
         return true
       end
 

data/lib/samagotchi/toolkit_command.rb

@@ -47,10 +47,7 @@ module Samagotchi
       # Nothing the prompt carries changes (full +delegate on full): only
       # the origin is saved, so a no-op choice still counts as user-selected.
       if after.prompt_key == before.prompt_key
-        if session.toolkit_origin != "chosen"
-          session.toolkit_origin = "chosen"
-          @save.call(session)
-        end
+        @save.call(session) if session.choose_toolkit_origin!
         return [listing(before) + "\n(no change to what the next turn declares)", false, nil]
       end