truffler 0.1.4 → 0.1.6

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,9 +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:)
+      def initialize(records:, query:, encoding:, encoding_status:, watermark:, explicit_action:, sources:, invite_row:, weights:, recount:,
+        local_weak: nil, relaxed_labels: [])
+        @local_weak = local_weak
+        @relaxed_labels = relaxed_labels
         @records = records
         @query = query
         @encoding = encoding
@@ -29,12 +32,25 @@ module Truffler
         records.map(&:id)
       end
 
-      # Applied filters, then boosts, then the time range, as `{key:, label:, kind:, name:}`.
+      # Whether the local list is too weak to stand alone, which starts the
+      # backup provider on the explicit action. An `:encoding_pending` row on
+      # a model with a `keyword` source invites Smart search without making
+      # the list weak.
+      def local_weak?
+        @local_weak.nil? ? invite_row.present? : @local_weak
+      end
+
+      # 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

@@ -3,15 +3,24 @@ module Truffler
     # Builds the one keystroke query of KTD8, scored per KTD20:
     #
     #   w_label * SUM(weight * value) over the intent's nonzero label keys
-    #   + w_text * text similarity (inline SQL, or the store's top-K CASE)
+    #   + w_text * text similarity (a top-K join, inline SQL, or the store's top-K CASE)
     #   + w_keyword * keyword hit + w_exact * exact-source hit
     #   + SOFT_KEYWORD * w_keyword * soft keyword hit
     #
     # A weighted dot product, not cosine: cosine would divide out magnitude
     # and let a record high on unrelated labels outrank the one the query
     # asked for. Hard filters are EXISTS subqueries that run before scoring.
+    #
+    # At scale: when every record past the filters is a candidate (label-only
+    # and filtered searches), label scores come from one grouped aggregate
+    # LEFT JOINed on record_id instead of a subquery per row. A store with
+    # `neighbors_sql` (NeighborStore on Postgres) is LEFT JOINed the same
+    # way, so text similarity is read from the tenant's top-K. Relation
+    # sources run once, as `id = ANY(ARRAY(subquery))` on Postgres.
     class Sql
       LABELS = "truffler_labels".freeze
+      LABEL_SCORES = "truffler_label_scores".freeze
+      NEIGHBORS = "truffler_neighbors".freeze
       # Share of the keyword weight a soft keyword hit adds (see Encoding).
       SOFT_KEYWORD = 0.25
 
@@ -38,7 +47,8 @@ module Truffler
       # filter the filter decides membership and text matches only rank.
       def candidates(scope)
         base = base(scope)
-        return base if label_only? || encoding.filters.any?
+        base = base.joins(Arel.sql(neighbors_join_sql)) if neighbors_sql
+        return base if every_base_record?
 
         conditions = [ keyword_sql, exact_sql, (text_candidate_sql if text_score_sql) ].compact
         base.where(Arel.sql(conditions.any? ? conditions.map { |condition| "(#{condition})" }.join(" OR ") : "1 = 0"))
@@ -46,19 +56,21 @@ module Truffler
 
       def relation(scope, limit: nil)
         relation = candidates(scope)
+        relation = relation.joins(Arel.sql(label_scores_join_sql)) if grouped_label_scores?
         relation = relation.select(Arel.sql("#{table}.*")) if relation.select_values.empty?
         relation = relation.select(*score_columns.map { |name, sql| Arel.sql("(#{sql}) AS #{name}") })
         relation = relation.reorder(*ordering)
         limit ? relation.limit(limit) : relation
       end
 
+      # The label term: a per-candidate subquery when sources narrow the
+      # candidates, else the grouped join's score.
       def label_score_sql
-        intent = encoding.intent_vector
-        return if intent.empty?
+        return if encoding.intent_vector.empty?
+        return "COALESCE(#{connection.quote_table_name(LABEL_SCORES)}.score, 0.0)" if grouped_label_scores?
 
-        cases = intent.map { |key, weight| "WHEN #{quote(key)} THEN #{Float(weight)} * #{label_column('value')}" }.join(" ")
-        "COALESCE((SELECT SUM(CASE #{label_column('label_key')} #{cases} ELSE 0.0 END) FROM #{quoted_labels} " \
-          "WHERE #{label_scope_sql} AND #{label_column('label_key')} IN (#{intent.keys.map { |key| quote(key) }.join(', ')})), 0.0)"
+        "COALESCE((SELECT SUM(#{label_case_sql}) FROM #{quoted_labels} " \
+          "WHERE #{label_scope_sql} AND #{label_keys_sql}), 0.0)"
       end
 
       def sources
@@ -67,7 +79,23 @@ module Truffler
       end
 
       def keywords
-        encoding.keywords(query)
+        @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
@@ -115,6 +143,41 @@ module Truffler
         range.to ? scope.where(arrived_at.lt(range.to)) : scope
       end
 
+      def label_case_sql
+        cases = encoding.intent_vector.map { |key, weight| "WHEN #{quote(key)} THEN #{Float(weight)} * #{label_column('value')}" }
+        "CASE #{label_column('label_key')} #{cases.join(' ')} ELSE 0.0 END"
+      end
+
+      def label_keys_sql
+        "#{label_column('label_key')} IN (#{encoding.intent_vector.keys.map { |key| quote(key) }.join(', ')})"
+      end
+
+      def grouped_label_scores?
+        encoding.intent_vector.any? && every_base_record?
+      end
+
+      # One aggregate over the tenant's rows for the intent's keys, which
+      # `index_truffler_labels_for_search` (with INCLUDE (record_id)) serves
+      # as an index-only scan.
+      def label_scores_join_sql
+        tenant = definition.scoped? ? " AND #{label_column('tenant_key')} = #{quote(tenant_key)}" : ""
+        scores = connection.quote_table_name(LABEL_SCORES)
+        "LEFT JOIN (SELECT #{label_column('record_id')} AS record_id, SUM(#{label_case_sql}) AS score FROM #{quoted_labels} " \
+          "WHERE #{label_column('record_type')} = #{quote(model.polymorphic_name)}#{tenant} AND #{label_keys_sql} " \
+          "GROUP BY #{label_column('record_id')}) #{scores} ON #{scores}.record_id = #{primary_key}"
+      end
+
+      def neighbors_sql
+        return @neighbors_sql if defined?(@neighbors_sql)
+
+        @neighbors_sql = (store.neighbors_sql(model, tenant_key: tenant_key, vector: vector) if vector && store.respond_to?(:neighbors_sql))
+      end
+
+      def neighbors_join_sql
+        neighbors = connection.quote_table_name(NEIGHBORS)
+        "LEFT JOIN (#{neighbors_sql}) #{neighbors} ON #{neighbors}.record_id = #{primary_key}"
+      end
+
       def label_filter_sql(key, threshold)
         "EXISTS (SELECT 1 FROM #{quoted_labels} WHERE #{label_scope_sql} AND #{label_column('label_key')} = #{quote(key)} " \
           "AND #{label_column('value')} >= #{Float(threshold)})"
@@ -171,7 +234,10 @@ module Truffler
       def text_score_sql
         return @text_score_sql if defined?(@text_score_sql)
 
-        @text_score_sql = (store.similarity_sql(model, tenant_key: tenant_key, vector: vector).to_s if vector && store)
+        @text_score_sql =
+          if neighbors_sql then "COALESCE(#{connection.quote_table_name(NEIGHBORS)}.similarity, 0.0)"
+          elsif vector && store then store.similarity_sql(model, tenant_key: tenant_key, vector: vector).to_s
+          end
       end
 
       def text_candidate_sql
@@ -186,9 +252,14 @@ module Truffler
         definition.scoped? ? model.where(definition.tenant_column => tenant_key) : model.all
       end
 
+      # An id list is the fast path. A relation runs once as an array on
+      # Postgres, where `IN (subquery)` becomes a hashed filter over every
+      # tenant row.
       def membership_sql(result)
         case result
-        when ActiveRecord::Relation then "#{primary_key} IN (#{result.reselect(result.klass.arel_table[result.klass.primary_key]).to_sql})"
+        when ActiveRecord::Relation
+          subquery = result.reselect(result.klass.arel_table[result.klass.primary_key]).to_sql
+          connection.adapter_name.match?(/postg/i) ? "#{primary_key} = ANY(ARRAY(#{subquery}))" : "#{primary_key} IN (#{subquery})"
         when nil then nil
         else
           ids = Array(result)

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
@@ -64,24 +67,33 @@ module Truffler
           if @encodings.encoded?(key) then @encodings.read_encoding(key, query)
           elsif @encodings.in_flight?(key) then @encoder.await(key, deadline: @deadline, query: query)
           end
-        encoding&.without(run.suppressed)
+        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.invite_row.present?, 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.4"
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: truffler
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Kieran Klaassen
@@ -202,6 +202,8 @@ files:
 - lib/generators/truffler/install/templates/initializer.rb.tt
 - lib/generators/truffler/install/templates/migration.rb.tt
 - lib/generators/truffler/upgrade/templates/backfill_spends_migration.rb.tt
+- lib/generators/truffler/upgrade/templates/backfill_spends_tenant_key_migration.rb.tt
+- lib/generators/truffler/upgrade/templates/labels_search_covering_migration.rb.tt
 - lib/generators/truffler/upgrade/upgrade_generator.rb
 - lib/tasks/truffler.rake
 - lib/tasks/truffler/bench.rake
@@ -224,9 +226,11 @@ files:
 - lib/truffler/clients/base.rb
 - lib/truffler/clients/callable.rb
 - lib/truffler/clients/cassette.rb
+- lib/truffler/clients/evaluator.rb
 - lib/truffler/clients/fake.rb
 - lib/truffler/clients/ruby_llm_typesafe.rb
 - lib/truffler/configuration.rb
+- lib/truffler/current.rb
 - lib/truffler/definition.rb
 - lib/truffler/embeddings.rb
 - lib/truffler/embeddings/backfill.rb
@@ -286,6 +290,7 @@ files:
 - lib/truffler/query_encoding/cache.rb
 - lib/truffler/query_encoding/encoder.rb
 - lib/truffler/query_encoding/prefetch.rb
+- lib/truffler/query_encoding/present_options.rb
 - lib/truffler/questions.rb
 - lib/truffler/railtie.rb
 - lib/truffler/records/backfill_spend.rb
@@ -300,6 +305,7 @@ files:
 - lib/truffler/search/filler.rb
 - lib/truffler/search/keystroke.rb
 - lib/truffler/search/query.rb
+- lib/truffler/search/relaxation.rb
 - lib/truffler/search/result.rb
 - lib/truffler/search/sql.rb
 - lib/truffler/search/time_phrase.rb