samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/llm/errors.rb

@@ -19,7 +19,8 @@ module Samagotchi
     # (#kind): the UIs print one line per kind, and #retryable? says whether
     # asking again could help.
     #
-    #   ConnectionError  no answer (refused, reset, timeout); RetryExhausted
+    #   ConnectionError  no answer (refused, reset, timeout); RetryExhausted,
+    #                    ConnectionRefused
     #   RateLimited      429, with retry_after when the server says
     #   ServerError      5xx or a server's error event mid-stream
     #   AuthError        401/403, or an API key variable that is not set
@@ -51,14 +52,14 @@ module Samagotchi
       # One line for the UIs, e.g. "auth failed for host fw: set FW_KEY".
       def summary = "error from host #{host}: #{detail}"
 
-      private
-
-      def default_retryable? = false
-
       # The message without its leading "host: ".
       def detail
         host && message.start_with?("#{host}: ") ? message.delete_prefix("#{host}: ") : message
       end
+
+      private
+
+      def default_retryable? = false
     end
 
     class ConnectionError < ProviderError
@@ -90,20 +91,29 @@ module Samagotchi
     end
 
     class AuthError < ProviderError
+      # What to try (LLM::ApiKey), added to the summary.
+      attr_accessor :hint
+
       def kind = :auth
 
-      def summary = "auth failed for host #{host}: #{detail}"
+      def summary = "auth failed for host #{host}: #{detail}#{"; #{hint}" if hint}"
     end
 
     class BadRequest < ProviderError
       TOOLS_HINT = "this model can't use tools, and chi needs them: pick another model (/model) or host"
 
-      def initialize(message = nil, context_overflow: false, tools_unsupported: false, **options)
+      # @param hint [String, nil] what to try, added to the summary
+      def initialize(message = nil, context_overflow: false, tools_unsupported: false, reasoning_refused: false, hint: nil,
+                     **options)
         @context_overflow = context_overflow
         @tools_unsupported = tools_unsupported
+        @reasoning_refused = reasoning_refused
+        @hint = hint
         super(message, **options)
       end
 
+      attr_reader :hint
+
       # The prompt is larger than the model's context window.
       def context_overflow? = @context_overflow
 
@@ -111,6 +121,10 @@ module Samagotchi
       # and chi always sends them.
       def tools_unsupported? = @tools_unsupported
 
+      # A 400 about reasoning or thinking: the request's thinking fields may
+      # be what the host refuses (gpt-oss: "Reasoning is mandatory").
+      def reasoning_refused? = @reasoning_refused
+
       def kind = :bad_request
 
       def summary
@@ -119,7 +133,7 @@ module Samagotchi
         elsif tools_unsupported?
           "host #{host} rejected the request: #{tools_detail}; #{TOOLS_HINT}"
         else
-          "host #{host} rejected the request: #{detail}"
+          "host #{host} rejected the request: #{detail}#{"; #{hint}" if hint}"
         end
       end
 
@@ -174,6 +188,19 @@ module Samagotchi
       def summary = "network error after #{attempts} attempts (host #{host}: #{last_error.class})"
     end
 
+    # A refused connection: nothing listens at the host's address. Not
+    # retried (a server that isn't running rarely starts within the backoff).
+    class ConnectionRefused < ConnectionError
+      attr_reader :address
+
+      def initialize(host:, address: nil, attempts: 1)
+        @address = address
+        super("#{host}: connection refused#{" at #{address}" if address}", host: host, retryable: false, attempts: attempts)
+      end
+
+      def summary = "can't reach host #{host}#{" at #{address}" if address} (connection refused) — is the server running?"
+    end
+
     # A stream that showed nothing (no text, reasoning or tool call) within
     # the host's first-token limit. A queued request can stay open for many
     # minutes on keep-alive comments alone, which reset the read timeout.
@@ -209,6 +236,8 @@ module Samagotchi
       TOOLS_UNSUPPORTED_RE = /support tool use|(does not|doesn't) support tools|tool choice requires --enable-auto-tool-choice/i
       # A model or server that can't take images (see VisionUnsupported).
       VISION_UNSUPPORTED_RE = /support image input|image input is not supported|mmproj/i
+      # A 400 about the thinking fields chi sent (Thinking.chat_fields).
+      REASONING_REFUSED_RE = /reasoning|thinking/i
       RETRYABLE_SERVER_STATUSES = [500, 502, 503, 504, 529].freeze
 
       module_function
@@ -230,7 +259,10 @@ module Samagotchi
         when 401, 403 then AuthError.new(text, **options)
         when 429 then RateLimited.new(text, retry_after: parse_retry_after(retry_after), **options)
         when 408 then ServerError.new(text, retryable: true, **options)
-        when 400..499 then BadRequest.new(text, tools_unsupported: TOOLS_UNSUPPORTED_RE.match?(message), **options)
+        when 400..499
+          tools = TOOLS_UNSUPPORTED_RE.match?(message)
+          BadRequest.new(text, tools_unsupported: tools,
+                               reasoning_refused: status == 400 && !tools && REASONING_REFUSED_RE.match?(message), **options)
         when 500..599
           ServerError.new(text, retryable: RETRYABLE_SERVER_STATUSES.include?(status),
                                 retry_after: parse_retry_after(retry_after), **options)

data/lib/samagotchi/llm/http.rb

@@ -6,6 +6,7 @@ require_relative "../config"
 require_relative "../version"
 require_relative "../log"
 require_relative "errors"
+require_relative "api_key"
 
 module Samagotchi
   module LLM
@@ -101,8 +102,12 @@ module Samagotchi
       # @param sleeper [#call] waits the given seconds (specs pass a no-op)
       # @param first_token_timeout [Numeric, nil] seconds a stream may take to
       #   show something (see #stream_lines); nil: no limit
-      def initialize(label:, open_timeout:, read_timeout:, retry_policy: nil, sleeper: nil, first_token_timeout: nil)
+      # @param api_key [ApiKey, nil] sent on every request; nil: no
+      #   Authorization header (a local server)
+      def initialize(label:, open_timeout:, read_timeout:, retry_policy: nil, sleeper: nil, first_token_timeout: nil,
+                     api_key: nil)
         @label = label
+        @api_key = api_key
         @open_timeout = open_timeout
         @read_timeout = read_timeout
         @first_token_timeout = first_token_timeout&.positive? ? first_token_timeout : nil
@@ -176,15 +181,18 @@ module Samagotchi
       private :stream_attempt
 
       # Send +request+ and return the response with its body read.
-      # @param retries [Boolean] false: one attempt, network errors raised as is
+      # @param retries [Boolean] false: one attempt, network errors raised as
+      #   is (Net::HTTP's own silent retry of an idempotent GET included)
       # @param check_status [Boolean] false: return an error response instead
       #   of raising its ProviderError
+      # @raise [RequestCancelled] when +cancel_controller+ cancels (with or
+      #   without retries)
       def fetch(uri, request, retries: true, check_status: true, open_timeout: nil, read_timeout: nil,
                 cancel_controller: nil, log_fields: {})
         identify(request)
         current = new_attempt_state(uri, request, log_fields, stream: false)
         attempt = lambda do |state|
-          start(uri, open_timeout: open_timeout, read_timeout: read_timeout) do |http|
+          start(uri, open_timeout: open_timeout, read_timeout: read_timeout, max_retries: retries ? nil : 0) do |http|
             state[:http] = http
             http.request(request).tap do |response|
               state[:status] = response.code.to_i
@@ -193,20 +201,30 @@ module Samagotchi
           end
         end
         logged(current) do
-          next attempt.call(current.merge!(attempts: 1)) unless retries
+          next with_retries(cancel_controller, nil, nil, current, &attempt) if retries
 
-          with_retries(cancel_controller, nil, nil, current, &attempt)
+          cancellable(cancel_controller, current) do
+            attempt.call(current.merge!(attempts: 1))
+          rescue StandardError => e
+            raise RequestCancelled.new(cancel_controller.reason) if !e.is_a?(RequestCancelled) && cancel_controller&.cancelled?
+
+            raise
+          end
         end
       end
 
       private
 
+      # User-Agent, and the host's key when it has one (AuthError, before
+      # any request, when its variable is not set).
       def identify(request)
         request["User-Agent"] = Samagotchi::USER_AGENT
+        @api_key&.authorize(request)
       end
 
-      def start(uri, open_timeout: nil, read_timeout: nil, &block)
+      def start(uri, open_timeout: nil, read_timeout: nil, max_retries: nil, &block)
         options = { open_timeout: open_timeout || @open_timeout, read_timeout: read_timeout || @read_timeout }
+        options[:max_retries] = max_retries if max_retries
         options[:use_ssl] = true if uri.scheme == "https"
         Net::HTTP.start(uri.host, uri.port, **options, &block)
       end
@@ -215,10 +233,29 @@ module Samagotchi
       # errors. The block gets a hash to put the attempt's Net::HTTP in, so a
       # cancel can reach its socket.
       def with_retries(cancel_controller, on_retry, on_network_error, current = { mutex: Mutex.new })
+        cancellable(cancel_controller, current) do
+          retrying(cancel_controller, on_retry, on_network_error, current) { |state| yield(state) }
+        end
+      end
+
+      # Runs the block with +cancel_controller+ able to abort it: a cancel
+      # closes the socket in current[:http] (or raises RequestCancelled in
+      # this thread while there is none).
+      def cancellable(cancel_controller, current)
         requesting_thread = Thread.current
         listener_id = cancel_controller&.on_cancel { |reason| abort_request(current, requesting_thread, reason) }
         raise RequestCancelled.new(cancel_controller.reason) if cancel_controller&.cancelled?
 
+        yield
+      ensure
+        # A cancel can call the listener after remove_listener returned (the
+        # controller calls listeners outside its lock); :done keeps it from
+        # raising into this thread once the request is over.
+        current[:mutex].synchronize { current[:done] = true }
+        cancel_controller&.remove_listener(listener_id)
+      end
+
+      def retrying(cancel_controller, on_retry, on_network_error, current)
         attempts = 0
         loop do
           attempts += 1
@@ -243,6 +280,12 @@ module Samagotchi
             raise unless self.class.network_error?(e)
 
             on_network_error&.call(e)
+            # Nothing is listening: asking again rarely helps, so it fails
+            # at once and says what to check.
+            if e.is_a?(Errno::ECONNREFUSED)
+              raise ConnectionRefused.new(host: @label, address: current[:address], attempts: attempts)
+            end
+
             delay = current[:streamed] ? nil : @retry_policy.delay_for(attempts)
             raise RetryExhausted.new(attempts: attempts, last_error: e, label: @label) if delay.nil?
 
@@ -251,12 +294,6 @@ module Samagotchi
             current.delete(:http)
           end
         end
-      ensure
-        # A cancel can call the listener after remove_listener returned (the
-        # controller calls listeners outside its lock); :done keeps it from
-        # raising into this thread once the request is over.
-        current[:mutex].synchronize { current[:done] = true }
-        cancel_controller&.remove_listener(listener_id)
       end
 
       # Runs one attempt (the block) under the first-token limit: a watchdog
@@ -302,7 +339,7 @@ module Samagotchi
       # closes, status, timings) and what its log line says.
       def new_attempt_state(uri, request, log_fields, stream:)
         purpose = log_fields[:purpose]&.to_s
-        { mutex: Mutex.new, started_at: monotonic_now, stream: stream,
+        { mutex: Mutex.new, started_at: monotonic_now, stream: stream, address: "#{uri.host}:#{uri.port}",
           level: LOGGED_PURPOSES.include?(purpose) ? :info : :debug,
           log: { host: @label, method: request.method, url: log_url(uri),
                  **log_fields.compact } }
@@ -326,7 +363,7 @@ module Samagotchi
                         ms: elapsed_ms(current), attempts: retried(current))
         result
       rescue RequestCancelled => e
-        Log.info(:http, "cancelled", **log_base(current), ms: elapsed_ms(current), reason: e.reason&.to_s)
+        Log.public_send(current[:level], :http, "cancelled", **log_base(current), ms: elapsed_ms(current), reason: e.reason&.to_s)
         raise
       rescue StandardError => e
         failure_level = current[:level] == :info ? :error : :debug
@@ -359,7 +396,8 @@ module Samagotchi
                                  status: error.is_a?(ProviderError) ? error.status : nil, error: error.class.name,
                                  msg: error.message.to_s[0, 300])
         on_retry&.call(attempt: attempts, max_retries: @retry_policy.max, next_delay: delay,
-                       error_class: error.class.name, error_message: error.message)
+                       error_class: error.class.name, error_message: error.message,
+                       status: error.is_a?(ProviderError) ? error.status : nil)
         wait(delay, cancel_controller)
       end
 
@@ -367,8 +405,10 @@ module Samagotchi
         status = response.code.to_i
         return if status.between?(200, 299)
 
-        raise ProviderErrors.from_response(status: status, body: response.body.to_s, host: @label,
-                                           retry_after: response["Retry-After"])
+        error = ProviderErrors.from_response(status: status, body: response.body.to_s, host: @label,
+                                             retry_after: response["Retry-After"])
+        error.hint ||= @api_key ? @api_key.hint : ApiKey.missing_hint(@label) if error.is_a?(AuthError)
+        raise error
       end
 
       def abort_request(current, requesting_thread, reason)

data/lib/samagotchi/llm/openai_chat.rb

@@ -3,6 +3,7 @@
 require "json"
 require "uri"
 require_relative "../config"
+require_relative "../sampling_settings"
 require_relative "errors"
 require_relative "http"
 require_relative "usage"
@@ -89,13 +90,13 @@ module Samagotchi
         @host_name = host_name.to_s
         @api_key_env = api_key_env
         @stream = stream
-        @env = env
         @models_ttl = models_ttl
         @models_mutex = Mutex.new
         open_timeout, read_timeout = timeouts(timeout)
         policy = retry_policy || (retries ? nil : HTTP::RetryPolicy.none)
         @http = HTTP.new(label: @host_name, open_timeout: open_timeout, read_timeout: read_timeout,
-                         retry_policy: policy, sleeper: sleeper, first_token_timeout: first_token_timeout)
+                         retry_policy: policy, sleeper: sleeper, first_token_timeout: first_token_timeout,
+                         api_key: ApiKey.for(api_key_env, host: @host_name, env: env))
       end
 
       # @param messages [Array<Hash>] wire messages (role, content, tool_calls,
@@ -111,9 +112,9 @@ module Samagotchi
       # @return [ChatResponse]
       def chat(messages:, model:, tools: [], cancel_controller: nil, on_delta: nil, on_retry: nil, options: {},
                session_id: nil)
-        request = post_request("#{@base_url}/chat/completions", request_body(messages, tools, model, options),
-                               session_id: session_id)
-        log_fields = { model: model, purpose: @purpose }
+        body = request_body(messages, tools, model, options)
+        request = post_request("#{@base_url}/chat/completions", body, session_id: session_id)
+        log_fields = { model: model, purpose: @purpose, sampling: sampling_summary(body) }
         return chat_once(request, cancel_controller, log_fields) unless @stream
 
         assembly = Assembly.new
@@ -183,20 +184,13 @@ module Samagotchi
       private
 
       def timeouts(timeout)
-        open_timeout = config_integer("server.open_timeout", 10)
-        read_timeout = config_integer("server.read_timeout", 600)
+        open_timeout = Samagotchi::Config.positive_seconds("server.open_timeout")
+        read_timeout = Samagotchi::Config.positive_seconds("server.read_timeout")
         return [open_timeout, read_timeout] unless timeout
 
         [[open_timeout, timeout].min, timeout]
       end
 
-      def config_integer(key, default)
-        value = Samagotchi::Config.get(key).to_i
-        value.positive? ? value : default
-      rescue StandardError
-        default
-      end
-
       def request_body(messages, tools, model, options)
         body = {
           model: model,
@@ -209,7 +203,14 @@ module Samagotchi
           body[:tools] = tools
           body[:tool_choice] = "auto"
         end
-        body.merge(options || {})
+        # A configured value replaces chi's own (temperature); nil drops it.
+        body.merge(options || {}).compact
+      end
+
+      # The body's fields beyond the conversation and the stream, for the
+      # log line: "temperature=0.6 presence_penalty=1.5".
+      def sampling_summary(body)
+        SamplingSettings.log_text(body.except(:model, :messages, :stream, :stream_options, :tools, :tool_choice))
       end
 
       # A String stays a String; an Array of parts passes as given.
@@ -278,25 +279,11 @@ module Samagotchi
         Net::HTTP::Post.new(uri).tap do |request|
           request["Content-Type"] = "application/json"
           request["Session-Id"] = session_id.to_s unless session_id.to_s.empty?
-          authorize(request)
           request.body = JSON.generate(body)
         end
       end
 
-      def get_request(uri)
-        Net::HTTP::Get.new(uri).tap { |request| authorize(request) }
-      end
-
-      def authorize(request)
-        return unless @api_key_env
-
-        key = @env[@api_key_env].to_s
-        if key.strip.empty?
-          raise AuthError.new("#{@host_name}: set #{@api_key_env} (the API key for host #{@host_name})",
-                              host: @host_name)
-        end
-        request["Authorization"] = "Bearer #{key}"
-      end
+      def get_request(uri) = Net::HTTP::Get.new(uri)
 
       def model_entries(body)
         return [] unless body.is_a?(Hash)

data/lib/samagotchi/log_subscriber.rb

@@ -27,8 +27,8 @@ module Samagotchi
       question_requested: [],
       question_answered: %i[id],
       question_cancelled: %i[id reason],
-      pending_input_merged: %i[iteration count],
-      generation_cancelled: %i[iteration]
+      generation_cancelled: %i[iteration],
+      empty_answer_retry: %i[iteration attempt of finish_reason thinking_chars]
     }.freeze
 
     # @param session_id [#call] the session the events are about (the
@@ -71,6 +71,15 @@ module Samagotchi
                                   exhausted: summary[:exhausted] || nil, **origin(event))
     end
 
+    # A plugin's steers by count and source, never their text.
+    def on_pending_input_merged(event)
+      steers = Array(event[:steers])
+      log(:info, :pending_input_merged, **event.slice(:iteration, :count),
+                                        steers: steers.empty? ? nil : steers.size,
+                                        steer_sources: steers.empty? ? nil : steers.map { |s| s[:source] }.uniq.join(","),
+                                        **origin(event))
+    end
+
     def on_turn_canceled(event)
       log(:info, :turn_canceled, ms: since(@turn_started_at), reason: event[:cancellation_reason], **origin(event))
     end
@@ -92,7 +101,7 @@ module Samagotchi
                                         ms: since(@generation_started_at.delete(event[:iteration])),
                                         served_model: event[:served_model], requested_model: event[:requested_model],
                                         content_length: event[:content_length],
-                                        thinking_chars: event[:thinking_chars])
+                                        thinking_chars: event[:thinking_chars], finish_reason: event[:finish_reason])
     end
 
     def on_generation_retrying(event)
@@ -125,6 +134,12 @@ module Samagotchi
       log(level, :hook_notice, hook: event[:hook], msg: event[:text].to_s[0, 300])
     end
 
+    # after_turn hooks presented the answer (AnswerDisplay): its size only
+    # (none for the display: nil that says nothing was presented).
+    def on_answer_display(event)
+      log(:info, :answer_display, chars: event[:display].to_s.length) if event[:display]
+    end
+
     # A card shown to the user (Engine#show_card): whose, which, and its
     # title (the body is the plugin's text; not logged).
     def on_card(event)

data/lib/samagotchi/memory_bundle/installer.rb

@@ -295,79 +295,81 @@ module Samagotchi
 
         warn_missing_needs(manifest) if manifest
 
-        # Write provenance (only if we had a manifest and not dry_run).
+        # Write provenance (only if we had a manifest and not dry_run). An
+        # upgrade with conflicts writes it too: the new version, the plugin's
+        # and hooks' new shas, and the old base for each conflicted file,
+        # marked conflict (chi bundle status shows it). Skipping it left the
+        # replaced plugin failing its sha check.
         if manifest && !@dry_run
-          skip_provenance = @upgrade && @conflicts.any? && !@force
-          unless skip_provenance
-            provenance_files = {}
-            if @upgrade && existing_provenance
-              all_files_in_bundle.each do |file_key|
-                target_path = File.join(target_dir, file_key)
-                next unless File.exist?(target_path)
-                status = @results[file_key] ? @results[file_key][:status].to_s : nil
-                if %w[kept noop conflict kept_pruned].include?(status)
-                  # Keep old base snapshot — do not overwrite with edited current
-                  # Use base snapshot as source if it exists to preserve old checksum
-                  base_path = provenance.base_path(file_key)
-                  if File.exist?(base_path)
-                    # Keep existing provenance entry by re-using base content
-                    # We still need to include it to prevent pruning, but with base content
-                    provenance_files[file_key] = base_path
-                  else
-                    provenance_files[file_key] = target_path
-                  end
+          provenance_files = {}
+          if @upgrade && existing_provenance
+            all_files_in_bundle.each do |file_key|
+              target_path = File.join(target_dir, file_key)
+              next unless File.exist?(target_path)
+              status = @results[file_key] ? @results[file_key][:status].to_s : nil
+              if %w[kept noop conflict kept_pruned].include?(status)
+                # Keep old base snapshot — do not overwrite with edited current
+                # Use base snapshot as source if it exists to preserve old checksum
+                base_path = provenance.base_path(file_key)
+                if File.exist?(base_path)
+                  # Keep existing provenance entry by re-using base content
+                  # We still need to include it to prevent pruning, but with base content
+                  provenance_files[file_key] = base_path
                 else
-                  # installed, updated, skipped — use current target (which is incoming for updated)
                   provenance_files[file_key] = target_path
                 end
+              else
+                # installed, updated, skipped — use current target (which is incoming for updated)
+                provenance_files[file_key] = target_path
               end
-              # Handle pruned but kept files (bundle removed file but local kept)
-              if existing_provenance[:files]
-                existing_provenance[:files].keys.each do |old_key|
-                  old_key_str = old_key.to_s
-                  next if all_files_in_bundle.include?(old_key_str)
-                  # If it was kept_pruned, include it with base content to prevent pruning
-                  if @results[old_key_str] && @results[old_key_str][:status].to_s == "kept_pruned"
-                    base_path = provenance.base_path(old_key_str)
-                    target_path = File.join(target_dir, old_key_str)
-                    # Use base if exists to keep old checksum, else target
-                    src = File.exist?(base_path) ? base_path : target_path
-                    provenance_files[old_key_str] = src if File.exist?(src)
-                  end
+            end
+            # Handle pruned but kept files (bundle removed file but local kept)
+            if existing_provenance[:files]
+              existing_provenance[:files].keys.each do |old_key|
+                old_key_str = old_key.to_s
+                next if all_files_in_bundle.include?(old_key_str)
+                # If it was kept_pruned, include it with base content to prevent pruning
+                if @results[old_key_str] && @results[old_key_str][:status].to_s == "kept_pruned"
+                  base_path = provenance.base_path(old_key_str)
+                  target_path = File.join(target_dir, old_key_str)
+                  # Use base if exists to keep old checksum, else target
+                  src = File.exist?(base_path) ? base_path : target_path
+                  provenance_files[old_key_str] = src if File.exist?(src)
                 end
               end
-            else
-              all_files_in_bundle.each do |file_key|
-                target_path = File.join(target_dir, file_key)
-                provenance_files[file_key] = target_path if File.exist?(target_path)
-              end
             end
-            # Build hooks metadata for provenance
-            hooks_for_provenance = {}
-            if manifest && manifest.hooks && !manifest.hooks.empty?
-              hooks_for_provenance = manifest.hooks
-            elsif hooks_files_for_provenance.any?
-              hooks_files_for_provenance.each do |basename, path|
-                next unless File.exist?(path)
-                sha = Digest::SHA256.hexdigest(File.read(path))
-                hooks_for_provenance[basename] = { "sha256" => "sha256:#{sha}", "event" => "", "on_error" => "skip", "priority" => 100 }
-              end
+          else
+            all_files_in_bundle.each do |file_key|
+              target_path = File.join(target_dir, file_key)
+              provenance_files[file_key] = target_path if File.exist?(target_path)
+            end
+          end
+          # Build hooks metadata for provenance
+          hooks_for_provenance = {}
+          if manifest && manifest.hooks && !manifest.hooks.empty?
+            hooks_for_provenance = manifest.hooks
+          elsif hooks_files_for_provenance.any?
+            hooks_files_for_provenance.each do |basename, path|
+              next unless File.exist?(path)
+              sha = Digest::SHA256.hexdigest(File.read(path))
+              hooks_for_provenance[basename] = { "sha256" => "sha256:#{sha}", "event" => "", "on_error" => "skip", "priority" => 100 }
             end
-            Provenance.new(name: @name).write(
-              files: provenance_files,
-              scope: target_scope,
-              version: manifest.version,
-              source_path: @source,
-              hooks: hooks_for_provenance,
-              trust_level: manifest.respond_to?(:trust_level) ? manifest.trust_level : nil,
-              source_commit: source_commit,
-              hooks_files: hooks_files_for_provenance,
-              guardrails_files: guardrail_files_for_provenance,
-              plugin_file: plugin_file_for_provenance,
-              requires_chi: manifest.requires_chi,
-              needs: manifest.needs
-            )
           end
+          Provenance.new(name: @name).write(
+            files: provenance_files,
+            scope: target_scope,
+            version: manifest.version,
+            source_path: @source,
+            hooks: hooks_for_provenance,
+            trust_level: manifest.respond_to?(:trust_level) ? manifest.trust_level : nil,
+            source_commit: source_commit,
+            hooks_files: hooks_files_for_provenance,
+            guardrails_files: guardrail_files_for_provenance,
+            plugin_file: plugin_file_for_provenance,
+            requires_chi: manifest.requires_chi,
+            needs: manifest.needs,
+            conflicts: @conflicts.keys
+          )
         end
 
         # Detect placeholders.