truffler 0.1.5 → 0.1.6

data/lib/truffler/query_encoding/present_options.rb

@@ -0,0 +1,54 @@
+module Truffler
+  module QueryEncoding
+    # With `config.skip_empty_options`, the choice options a tenant actually
+    # has: storage keys with at least one label row at or above
+    # `config.choice_min_probability` (above 0.0 when that is nil). Query
+    # encoding offers Jev only these, so it cannot pick "Source: email" in a
+    # tenant with no email sources.
+    #
+    # The set is digested into the encoding cache key, so encodings refresh
+    # when an option appears. It is read through the cache store for TTL, so
+    # a keystroke stays one SELECT; a new option reaches query encoding (and
+    # the cache key) within TTL.
+    class PresentOptions
+      TTL = 5.minutes
+
+      def initialize(store: Truffler.config.cache_store)
+        @store = store
+      end
+
+      def self.enabled?
+        Truffler.config.skip_empty_options == true
+      end
+
+      # The present storage keys among `labels`' choice options, or nil when
+      # skip_empty_options is off.
+      def keys(model, labels, tenant_key:)
+        return unless self.class.enabled?
+
+        candidates = labels.values.select { |label| label.type == :choice }.flat_map { |label| label.storage_keys(tenant_key) }.sort
+        return Set.new if candidates.empty?
+
+        min = Truffler.config.choice_min_probability
+        cache_key = "truffler/present_options/#{Canonical.digest(record_type: model.polymorphic_name, tenant_key: tenant_key&.to_s,
+          keys: candidates, min: min)}"
+        Set.new(@store.fetch(cache_key, expires_in: TTL) { present(model, candidates, tenant_key, min) })
+      end
+
+      # A label's options narrowed to `present` (all of them when nil).
+      def self.options(label, tenant_key, present)
+        options = label.options(tenant_key)
+        present ? options.select { |option, _| present.include?("#{label.key}:#{option}") } : options
+      end
+
+      private
+
+      def present(model, candidates, tenant_key, min)
+        rows = Records::Label.where(record_type: model.polymorphic_name, label_key: candidates)
+        rows = rows.where(tenant_key: tenant_key.to_s) if model.truffler_definition.scoped?
+        rows = min ? rows.where(value: min..) : rows.where(Records::Label.arel_table[:value].gt(0.0))
+        rows.distinct.pluck(:label_key).sort
+      end
+    end
+  end
+end

data/lib/truffler/records/backfill_spend.rb

@@ -6,6 +6,7 @@ module Truffler
     # settled in SQL, never read, added to, and written back.
     class BackfillSpend < ActiveRecord::Base
       self.table_name = "truffler_backfill_spends"
+      TENANT_KEY_RECHECK = 1.minute
 
       scope :for_model, ->(model) { where(record_type: model.polymorphic_name) }
 
@@ -23,20 +24,49 @@ module Truffler
       end
 
       # Before `rails g truffler:upgrade` adds tenant_key, every tenant
-      # shares the app-wide row.
-      def self.ledger(model, version, tenant_key: nil)
+      # shares the app-wide row. Before 0.1.6 rows were keyed by the whole
+      # vocabulary version; pass it as `legacy_version:` and the first lookup
+      # takes that row over instead of starting from zero.
+      def self.ledger(model, version, tenant_key: nil, legacy_version: nil)
         attributes = { record_type: model.polymorphic_name, vocabulary_version: version }
         attributes[:tenant_key] = tenant_key if tenant_ledgers?
+        adopt(attributes, legacy_version) if legacy_version && legacy_version != version
         create_or_find_by!(attributes)
       end
 
+      def self.adopt(attributes, legacy_version)
+        return if exists?(attributes)
+
+        where(attributes.merge(vocabulary_version: legacy_version)).update_all(vocabulary_version: attributes[:vocabulary_version])
+      rescue ActiveRecord::RecordNotUnique
+        nil
+      end
+      private_class_method :adopt
+
+      # A worker booted before `db:migrate` added tenant_key has the old
+      # columns cached, so a miss reloads them at most once per
+      # TENANT_KEY_RECHECK and the worker moves to tenant ledgers without a
+      # restart.
       def self.tenant_ledgers?
         return true if column_names.include?("tenant_key")
 
+        if recheck_tenant_key?
+          reset_column_information
+          return true if column_names.include?("tenant_key")
+        end
         warn_missing_tenant_key
         false
       end
 
+      def self.recheck_tenant_key?
+        now = Time.current
+        return false if @tenant_key_checked_at && now - @tenant_key_checked_at < TENANT_KEY_RECHECK
+
+        @tenant_key_checked_at = now
+        true
+      end
+      private_class_method :recheck_tenant_key?
+
       def self.warn_missing_tenant_key
         return if @missing_tenant_warned
 

data/lib/truffler/search/encoding.rb

@@ -65,15 +65,30 @@ module Truffler
         keep = ->(key, _) { !suppressed.include?(key) && !suppressed.include?(self.class.split_key(key).first) }
         kept = { filters: filters.select(&keep), boosts: boosts.select(&keep), intent_vector: intent_vector.select(&keep) }
         applied = kept.values.flat_map(&:keys).to_set
-        freed = label_term_sources.select { |_, keys| keys.any? && keys.none? { |key| applied.include?(key) } }.keys
+        freed = freed_words(applied)
         kept_time = (time unless suppressed.include?(TimeRange.key))
         keywords = keyword_tokens && (keyword_tokens + freed).uniq
         if keywords && applied.empty? && kept_time.nil?
           keywords = Filler.keywords(keywords + filler_tokens, anchored: false, keep: keep_words.respond_to?(:call) ? keep_words.call : keep_words)
         end
-        with(**kept, time: kept_time, label_term_tokens: label_term_tokens - freed,
-          label_term_sources: label_term_sources.except(*freed), soft_keyword_tokens: soft_keyword_tokens - freed,
-          keyword_tokens: keywords)
+        with(**kept, time: kept_time, **free(freed, keywords))
+      end
+
+      # The encoding with the filters `keys` demoted to soft boosts (zero-result
+      # relaxation, see Relaxation): they stay in the intent vector, at their
+      # intent weight or DEFAULT_BOOST when filtering gave them none, so records
+      # that match still rank first, but nothing requires them. A label term
+      # whose every applied source was relaxed becomes a keyword again, as in
+      # `without`.
+      def relax(keys)
+        relaxed = filters.slice(*Array(keys).map(&:to_s))
+        return self if relaxed.empty?
+
+        soft = relaxed.to_h { |key, _| [ key, intent_vector[key] || boosts[key] || QueryEncoding::DEFAULT_BOOST ] }
+        kept_filters = filters.except(*relaxed.keys)
+        freed = freed_words((kept_filters.keys + boosts.keys + intent_vector.keys).to_set - relaxed.keys)
+        with(filters: kept_filters, boosts: boosts.merge(soft), intent_vector: intent_vector.merge(soft),
+          **free(freed, keyword_tokens && (keyword_tokens + freed).uniq))
       end
 
       # Splits a storage key into its label key and choice option. Lens keys
@@ -113,6 +128,16 @@ module Truffler
 
       private
 
+      # Label terms none of whose source keys is still applied.
+      def freed_words(applied)
+        label_term_sources.select { |_, keys| keys.any? && keys.none? { |key| applied.include?(key) } }.keys
+      end
+
+      def free(freed, keywords)
+        { label_term_tokens: label_term_tokens - freed, label_term_sources: label_term_sources.except(*freed),
+          soft_keyword_tokens: soft_keyword_tokens - freed, keyword_tokens: keywords }
+      end
+
       def weights(hash)
         hash.to_h.to_h { |key, weight| [ key.to_s, Float(weight) ] }
       end

data/lib/truffler/search/encoding_cache.rb

@@ -62,7 +62,18 @@ module Truffler
         definition = model.truffler_definition
         tenant = tenant_key&.to_s if definition.per_tenant_vocabulary?
         version = definition.vocabulary.encoding_version(tenant_key: tenant_key&.to_s, user_key: user_key)
-        Canonical.digest(record_type: model.polymorphic_name, query: query.normalized, vocabulary_version: version, tenant_key: tenant)
+        parts = { record_type: model.polymorphic_name, query: query.normalized, vocabulary_version: version, tenant_key: tenant }
+        present = present_options(model, tenant_key, user_key)
+        Canonical.digest(present ? parts.merge(present_options: Canonical.digest(present.to_a.sort)) : parts)
+      end
+
+      # With skip_empty_options, the tenant's present choice options (see
+      # QueryEncoding::PresentOptions), so an encoding refreshes when one appears.
+      def present_options(model, tenant_key, user_key)
+        return unless QueryEncoding::PresentOptions.enabled?
+
+        labels = model.truffler_definition.vocabulary.labels_for(tenant_key: tenant_key&.to_s, user_key: user_key)
+        QueryEncoding::PresentOptions.new.keys(model, labels, tenant_key: tenant_key&.to_s)
       end
     end
   end

data/lib/truffler/search/keystroke.rb

@@ -36,26 +36,36 @@ module Truffler
       end
 
       def call
-        started = Instrumentation.monotonic_ms
-        watermark = Time.current
-        explicit_action = surface_action
-        cached = read_encoding
-        status = encoding_status(cached)
-        encoding = visible_lenses_only(with_time(cached)&.without(suppressed, keep_words: label_words), record_usage: true)
-        sql = sql(encoding)
-        records = sql.relation(scope, limit: limit).to_a
-        result = Result.new(records: records, query: query, encoding: encoding, encoding_status: status, watermark: watermark,
-          explicit_action: explicit_action, sources: sql.sources, invite_row: invite_row(records, cached, status),
-          local_weak: local_weak?(records, cached), weights: @weights, recount: ->(since) { count(since: since) })
-        instrument(result, started)
-        result
+        Current.scope do
+          started = Instrumentation.monotonic_ms
+          watermark = Time.current
+          explicit_action = surface_action
+          cached = read_encoding
+          status = encoding_status(cached)
+          encoding = visible_lenses_only(with_time(cached)&.without(suppressed, keep_words: label_words), record_usage: true)
+          sql = sql(encoding)
+          records = sql.relation(scope, limit: limit).to_a
+          relaxed = relax(encoding, records)
+          records, encoding, sql = relaxed.records, relaxed.encoding, sql(relaxed.encoding) if relaxed
+          relaxed_labels = relaxed&.relaxed_labels.to_a
+          result = Result.new(records: records, query: query, encoding: encoding, encoding_status: status, watermark: watermark,
+            explicit_action: explicit_action, sources: sql.sources, invite_row: invite_row(records, cached, status),
+            local_weak: local_weak?(records, cached), weights: @weights, relaxed_labels: relaxed_labels,
+            recount: ->(since) { count(since: since, relaxed: relaxed_labels) })
+          instrument(result, started)
+          result
+        end
       end
 
       # How many records the same search would return that arrived after
-      # `since` (R25). Reads the cache only and never prefetches.
-      def count(since:)
-        sql(visible_lenses_only(with_time(read_encoding)&.without(suppressed, keep_words: label_words))).candidates(scope)
-          .where(model.arel_table[@definition.arrived_at_column].gt(since)).count
+      # `since` (R25), with the filters `relaxed` demoted as the search did.
+      # Reads the cache only and never prefetches.
+      def count(since:, relaxed: [])
+        Current.scope do
+          encoding = visible_lenses_only(with_time(read_encoding)&.without(suppressed, keep_words: label_words))
+          sql(relaxed.any? ? encoding&.relax(relaxed) : encoding).candidates(scope)
+            .where(model.arel_table[@definition.arrived_at_column].gt(since)).count
+        end
       end
 
       private
@@ -138,6 +148,13 @@ module Truffler
         Sql.new(model, tenant_key: tenant_key, query: query, encoding: encoding, vector: read_vector, weights: @weights)
       end
 
+      # Only an empty result under filters pays for relaxation.
+      def relax(encoding, records)
+        return unless records.empty? && encoding&.filters&.any?
+
+        Relaxation.new(model, encoding, sql: method(:sql)).call(scope, limit: limit)
+      end
+
       # R21: the Smart search row. A query whose encoding is not cached yet
       # invites the action even when a blind index or keyword matched,
       # because a first-time intent query resolves on the action (AE10): on a
@@ -163,7 +180,7 @@ module Truffler
 
       def instrument(result, started)
         payload = { record_type: model.polymorphic_name, tenant_key: tenant_key, surface: surface, outcome: result.encoding_status,
-          result_count: result.records.size, filter_count: result.encoding&.filters&.size.to_i,
+          result_count: result.records.size, filter_count: result.encoding&.filters&.size.to_i, relaxed_count: result.relaxed_labels.size,
           boost_count: result.encoding&.intent_vector&.size.to_i, sources: result.sources.map(&:to_s),
           reason: result.invite_row&.dig(:reason), latency_ms: Instrumentation.elapsed_ms(started) }
         payload[:query_digest] = Misses.digest(:query, query.normalized) if Misses.encrypted_model?(model)

data/lib/truffler/search/relaxation.rb

@@ -0,0 +1,95 @@
+module Truffler
+  module Search
+    # Zero-result relaxation (0.1.6). When a search under the encoding's
+    # filters returns nothing, the filters are demoted to soft boosts
+    # (Encoding#relax) and the words they consumed become keywords again.
+    # It relaxes as little as it can: first only the filters no record in
+    # the tenant carries at their threshold ("Source: email" in a tenant with
+    # no email sources), keeping the rest hard; if that still finds nothing,
+    # every filter, but only when the words given back (or an exact or vector
+    # match) still narrow the search: relaxing into "every record in the
+    # tenant" would show unrelated results, so that stays empty.
+    #
+    # Both attempts run as one UNION ALL query, so relaxation costs a single
+    # extra SELECT and only on an empty result. Each "these filters are
+    # missing" branch is gated on label presence in the tenant, so at most
+    # one of them can return rows; the relax-everything branch ranks after
+    # it. With more than MAX_PARTIAL_FILTERS filters only the
+    # relax-everything branch runs, to bound the branch count (2^n - 1).
+    class Relaxation
+      MAX_PARTIAL_FILTERS = 3
+      TIER = "truffler_relaxed_tier".freeze
+      BRANCH = "truffler_relaxed_branch".freeze
+      SCORE_COLUMNS = %i[truffler_score truffler_label_score truffler_text_score truffler_keyword_score truffler_exact_score].freeze
+
+      Outcome = Data.define(:records, :encoding, :relaxed_labels)
+
+      # `sql` builds the search's Sql for an encoding.
+      def initialize(model, encoding, sql:)
+        @model = model
+        @encoding = encoding
+        @sql = sql
+      end
+
+      # The relaxed search's outcome, or nil when there is no filter to relax
+      # or the relaxed search is still empty.
+      def call(scope, limit: nil)
+        filters = @encoding&.filters.to_h
+        return if filters.empty?
+
+        branches = partial_branches(filters.keys)
+        branches << filters.keys unless @sql.call(@encoding.relax(filters.keys)).every_base_record?
+        return if branches.empty?
+
+        rows = @model.find_by_sql(union_sql(scope, filters, branches, limit))
+        return if rows.empty?
+
+        partial, full = rows.partition { |row| Integer(row[TIER]) == 1 }
+        records = partial.presence || full
+        relaxed = branches.fetch(Integer(records.first[BRANCH]))
+        Outcome.new(records: records, encoding: @encoding.relax(relaxed), relaxed_labels: relaxed)
+      end
+
+      private
+
+      # Every nonempty proper subset of the filters, as a "missing" set.
+      def partial_branches(keys)
+        return [] if keys.size > MAX_PARTIAL_FILTERS
+
+        (1...keys.size).flat_map { |size| keys.combination(size).to_a }
+      end
+
+      def union_sql(scope, filters, branches, limit)
+        present = ->(key) { @sql.call(@encoding).label_present_sql(key, filters.fetch(key)) }
+        selects = branches.each_with_index.map do |missing, index|
+          full = missing.size == filters.size
+          guard = (filters.keys - missing).map { |key| present.call(key) } + missing.map { |key| "NOT #{present.call(key)}" }
+          branch_sql(scope, missing, index, tier: full ? 0 : 1, guard: full ? [] : guard, limit: limit)
+        end
+        sql = "SELECT * FROM (#{selects.join(' UNION ALL ')}) truffler_relaxed ORDER BY #{ordering.join(', ')}"
+        limit ? "#{sql} LIMIT #{Integer(limit)}" : sql
+      end
+
+      def branch_sql(scope, missing, index, tier:, guard:, limit:)
+        search = @sql.call(@encoding.relax(missing))
+        alias_name = "truffler_relaxed_#{index}"
+        scores = search.score_column_names
+        columns = @model.column_names.map { |name| "#{alias_name}.#{quote_column(name)}" } +
+          SCORE_COLUMNS.map { |name| scores.include?(name) ? "#{alias_name}.#{name}" : "0.0 AS #{name}" } +
+          [ "#{tier} AS #{TIER}", "#{index} AS #{BRANCH}" ]
+        where = guard.any? ? " WHERE #{guard.join(' AND ')}" : ""
+        "SELECT #{columns.join(', ')} FROM (#{search.relation(scope, limit: limit).to_sql}) #{alias_name}#{where}"
+      end
+
+      def ordering
+        order_column, direction = @model.truffler_definition.order
+        [ "#{TIER} DESC", "truffler_score DESC", ("#{quote_column(order_column)} #{direction == :asc ? 'ASC' : 'DESC'}" if order_column),
+          "#{quote_column(@model.primary_key)} DESC" ].compact
+      end
+
+      def quote_column(name)
+        @model.connection.quote_column_name(name)
+      end
+    end
+  end
+end

data/lib/truffler/search/result.rb

@@ -10,11 +10,12 @@ module Truffler
       SCORE_COLUMNS = { label: "truffler_label_score", text: "truffler_text_score", keyword: "truffler_keyword_score",
         exact: "truffler_exact_score" }.freeze
 
-      attr_reader :records, :query, :encoding, :encoding_status, :watermark, :explicit_action, :sources, :invite_row
+      attr_reader :records, :query, :encoding, :encoding_status, :watermark, :explicit_action, :sources, :invite_row, :relaxed_labels
 
       def initialize(records:, query:, encoding:, encoding_status:, watermark:, explicit_action:, sources:, invite_row:, weights:, recount:,
-        local_weak: nil)
+        local_weak: nil, relaxed_labels: [])
         @local_weak = local_weak
+        @relaxed_labels = relaxed_labels
         @records = records
         @query = query
         @encoding = encoding
@@ -39,12 +40,17 @@ module Truffler
         @local_weak.nil? ? invite_row.present? : @local_weak
       end
 
-      # Applied filters, then boosts, then the time range, as `{key:, label:, kind:, name:}`.
+      # Applied filters, then relaxed filters, then boosts, then the time range,
+      # as `{key:, label:, kind:, name:}`. A filter relaxed because it left
+      # nothing to show (`relaxed_labels`) keeps its filter chip with
+      # `relaxed: true`, so the host can say "No email sources; showing
+      # keyword matches".
       def chips
         return [] unless encoding
 
-        filters = encoding.filters.keys.map { |key| chip(key, :filter) }
-        chips = filters + (encoding.boosts.keys - encoding.filters.keys).map { |key| chip(key, :boost) }
+        filters = encoding.filters.keys.map { |key| chip(key, :filter) } +
+          relaxed_labels.map { |key| chip(key, :filter).merge(relaxed: true) }
+        chips = filters + (encoding.boosts.keys - encoding.filters.keys - relaxed_labels).map { |key| chip(key, :boost) }
         time = encoding.time
         time ? chips + [ { key: TimeRange.key, label: TimeRange.key, kind: :time, name: time.name } ] : chips
       end

data/lib/truffler/search/sql.rb

@@ -82,6 +82,22 @@ module Truffler
         @keywords ||= encoding.keywords(query, keep: -> { Filler.label_words(definition, tenant_key) })
       end
 
+      # Whether any record in the tenant carries `key` at or above `threshold`.
+      def label_present_sql(key, threshold)
+        tenant = definition.scoped? ? " AND #{label_column('tenant_key')} = #{quote(tenant_key)}" : ""
+        "EXISTS (SELECT 1 FROM #{quoted_labels} WHERE #{label_column('record_type')} = #{quote(model.polymorphic_name)}#{tenant} " \
+          "AND #{label_column('label_key')} = #{quote(key)} AND #{label_column('value')} >= #{Float(threshold)})"
+      end
+
+      def score_column_names
+        score_columns.keys
+      end
+
+      # Every record past the tenant, time, and filters is a candidate.
+      def every_base_record?
+        label_only? || encoding.filters.any?
+      end
+
       private
 
       def definition
@@ -136,11 +152,6 @@ module Truffler
         "#{label_column('label_key')} IN (#{encoding.intent_vector.keys.map { |key| quote(key) }.join(', ')})"
       end
 
-      # Every record past the tenant, time, and filters is a candidate.
-      def every_base_record?
-        label_only? || encoding.filters.any?
-      end
-
       def grouped_label_scores?
         encoding.intent_vector.any? && every_base_record?
       end

data/lib/truffler/smart_search/dispatcher.rb

@@ -21,23 +21,26 @@ module Truffler
       end
 
       def call(run)
-        return unless run.status == :pending && run.model.try(:truffler_definition)
+        Current.scope do
+          return unless run.status == :pending && run.model.try(:truffler_definition)
 
-        start_provider(run)
-        decision = @budget.admit(priority: :rerank, user_key: run.user_key)
-        if decision.denied?
-          run.pause!(decision.reason)
-          return
-        end
+          start_provider(run)
+          decision = @budget.admit(priority: :rerank, user_key: run.user_key)
+          if decision.denied?
+            run.pause!(decision.reason)
+            return
+          end
 
-        encoding = await_encoding(run)
-        candidate_ids = filter(run, encoding)
-        return if run.cancelled?
+          encoding = await_encoding(run)
+          candidate_ids, encoding, relaxed = filter(run, encoding)
+          return if run.cancelled?
 
-        run.plan!(candidate_ids: candidate_ids, chunk_size: @config.rerank_chunk_size, filters: encoding&.filters&.keys.to_a)
-        run.chunk_count.times { |index| @enqueue.call(run, index) }
-        run.ping(SMART) if candidate_ids.empty?
-        candidate_ids
+          run.plan!(candidate_ids: candidate_ids, chunk_size: @config.rerank_chunk_size, filters: encoding&.filters&.keys.to_a,
+            relaxed_labels: relaxed)
+          run.chunk_count.times { |index| @enqueue.call(run, index) }
+          run.ping(SMART) if candidate_ids.empty?
+          candidate_ids
+        end
       end
 
       private
@@ -67,21 +70,30 @@ module Truffler
         encoding&.without(run.suppressed, keep_words: -> { Search::Filler.label_words(model.truffler_definition, run.tenant_key) })
       end
 
-      # The snapshot narrowed to what the encoding allows, in the tenant, in
-      # the keystroke ranking the encoding gives (or snapshot order without
-      # one), capped at `rerank_depth`.
+      # `[candidate_ids, encoding, relaxed_labels]`: the snapshot narrowed to
+      # what the encoding allows, in the tenant, in the keystroke ranking the
+      # encoding gives (or snapshot order without one), capped at
+      # `rerank_depth`. When the filters leave nothing, they relax as on the
+      # keystroke (Search::Relaxation) rather than rerank an empty set.
       def filter(run, encoding)
         model = run.model
         pool = model.where(model.primary_key => run.pool_ids)
-        sql = Search::Sql.new(model, tenant_key: run.tenant_key, query: run.search_query, encoding: encoding)
-        allowed = sql.base(pool).pluck(model.primary_key)
+        sql = ->(for_encoding) { Search::Sql.new(model, tenant_key: run.tenant_key, query: run.search_query, encoding: for_encoding) }
         ids = if encoding.nil? || encoding.empty?
-          run.pool_ids & allowed
+          run.pool_ids & sql.call(encoding).base(pool).pluck(model.primary_key)
         else
-          ranked = sql.relation(pool).map(&:id)
-          ranked + ((run.pool_ids & allowed) - ranked)
+          ranked(run, pool, sql.call(encoding).relation(pool).map(&:id), sql.call(encoding))
         end
-        ids.first(@config.rerank_depth)
+        relaxed = (Search::Relaxation.new(model, encoding, sql: sql).call(pool) if ids.empty? && encoding&.filters&.any?)
+        if relaxed
+          encoding = relaxed.encoding
+          ids = ranked(run, pool, relaxed.records.map(&:id), sql.call(encoding))
+        end
+        [ ids.first(@config.rerank_depth), encoding, relaxed&.relaxed_labels.to_a ]
+      end
+
+      def ranked(run, pool, ranked_ids, sql)
+        ranked_ids + ((run.pool_ids & sql.base(pool).pluck(run.model.primary_key)) - ranked_ids)
       end
     end
   end

data/lib/truffler/smart_search/reranker.rb

@@ -24,12 +24,14 @@ module Truffler
       # Scores chunk `index` of the run and appends it to the buckets.
       # Returns :done, :cancelled, :paused, :failed, or :skipped.
       def call(run, index)
-        return :skipped unless run.active? && run.chunk_ids(index) && !run.chunk_resolved?(index)
+        Current.scope do
+          return :skipped unless run.active? && run.chunk_ids(index) && !run.chunk_resolved?(index)
 
-        started = Instrumentation.monotonic_ms
-        outcome = rerank(run, index)
-        instrument(run, index, outcome, started)
-        outcome
+          started = Instrumentation.monotonic_ms
+          outcome = rerank(run, index)
+          instrument(run, index, outcome, started)
+          outcome
+        end
       end
 
       def request(run, records)

data/lib/truffler/smart_search/run.rb

@@ -145,6 +145,12 @@ module Truffler
         Array(plan&.fetch("filters", nil))
       end
 
+      # Filters the awaited encoding applied that were relaxed because they
+      # left no candidate (see Search::Relaxation).
+      def relaxed_labels
+        Array(plan&.fetch("relaxed_labels", nil))
+      end
+
       def chunk(index)
         store.read(id, "chunk/#{index}") unless expired?
       end
@@ -212,9 +218,10 @@ module Truffler
         true
       end
 
-      def plan!(candidate_ids:, chunk_size:, filters:)
+      def plan!(candidate_ids:, chunk_size:, filters:, relaxed_labels: [])
         store.write(id, "plan", { "candidate_ids" => candidate_ids, "chunks" => candidate_ids.each_slice(chunk_size).to_a,
-          "filters" => filters, "thresholds" => Truffler.config.smart_thresholds.transform_keys(&:to_s) })
+          "filters" => filters, "relaxed_labels" => relaxed_labels,
+          "thresholds" => Truffler.config.smart_thresholds.transform_keys(&:to_s) })
       end
 
       # Appends one chunk's `[[id, score], ...]`, sorted by score within the
@@ -281,7 +288,7 @@ module Truffler
           explicit_action: explicit_action, buckets: found, pending: BUCKETS.index_with { active? },
           collapsed: collapsed_by_default, no_strong_matches: current == :complete && found[:strong].empty?,
           promoted_ids: (found[:strong] + found[:possible]).map { |entry| entry[:id] }, applied_filters: applied_filters,
-          sections: { provider: provider_section.to_h.symbolize_keys } }
+          relaxed_labels: relaxed_labels, sections: { provider: provider_section.to_h.symbolize_keys } }
       end
 
       def as_json(*)

data/lib/truffler/smart_search/starter.rb

@@ -26,17 +26,19 @@ module Truffler
       end
 
       def call
-        result = keystroke.call
-        local_ids = result.ids
-        run = Run.create(@model, query: @query.raw.strip, tenant_key: keystroke.tenant_key, user_key: keystroke.user_key,
-          surface: keystroke.surface, suppressed: @suppressed, pool_ids: pool(result, local_ids), local_ids: local_ids,
-          local_weak: result.local_weak?, explicit_action: result.explicit_action, store: @store)
-        previous = @store.supersede(run.record_type, run.tenant_key, run.user_key, run.surface, run.id)
-        Run.load(previous, store: @store).cancel! if previous
-        Instrumentation.instrument(:smart_search, run_id: run.id, record_type: run.record_type, tenant_key: run.tenant_key,
-          surface: run.surface, candidate_count: run.pool_ids.size, local_count: local_ids.size)
-        @dispatch.call(run)
-        run
+        Current.scope do
+          result = keystroke.call
+          local_ids = result.ids
+          run = Run.create(@model, query: @query.raw.strip, tenant_key: keystroke.tenant_key, user_key: keystroke.user_key,
+            surface: keystroke.surface, suppressed: @suppressed, pool_ids: pool(result, local_ids), local_ids: local_ids,
+            local_weak: result.local_weak?, explicit_action: result.explicit_action, store: @store)
+          previous = @store.supersede(run.record_type, run.tenant_key, run.user_key, run.surface, run.id)
+          Run.load(previous, store: @store).cancel! if previous
+          Instrumentation.instrument(:smart_search, run_id: run.id, record_type: run.record_type, tenant_key: run.tenant_key,
+            surface: run.surface, candidate_count: run.pool_ids.size, local_count: local_ids.size)
+          @dispatch.call(run)
+          run
+        end
       end
 
       private

data/lib/truffler/version.rb

@@ -1,3 +1,3 @@
 module Truffler
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/truffler/vocabulary.rb

@@ -39,6 +39,16 @@ module Truffler
       Canonical.digest(fingerprints(tenant_key: tenant_key, user_key: user_key, all_users: all_users))
     end
 
+    # The version backfill spend ledgers are keyed by: the fingerprints of the
+    # labels Jev is asked only. Supplied labels cost nothing, so changing one
+    # (an option added to a `from:` choice included) never starts a new
+    # ledger. Without supplied labels it equals `version`, so ledger rows
+    # written before 0.1.6 keep their key.
+    def ledger_version(tenant_key: nil, user_key: nil, all_users: false)
+      asked = labels_for(tenant_key: tenant_key, user_key: user_key, all_users: all_users).reject { |_, label| label.supplied? }
+      Canonical.digest(asked.transform_values { |label| fingerprint_of(label, tenant_key) })
+    end
+
     # The version query encodings are cached under: the labeling version plus
     # a digest of the wording only query encoding reads (label descriptions,
     # option descriptions and search texts), which labeling never sees for