lex-apollo 0.4.30 → 0.4.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: facad4c6e5cf4da1497d5d6de01daa13310bc8762274e227e9ff7ead72c761a6
-  data.tar.gz: 37a7098b002770c827173135a5510eeb7651f0705ef6f80ded0f8433a012bee1
+  metadata.gz: b3132a716f6bac3837f9532c674d4d10aaa20326dae47bb2465ad8c3339702ce
+  data.tar.gz: 467ad8bb7e6a6851197d5b4f6ef9bf09b24b60d497e57eba821cabf47763f2e4
 SHA512:
-  metadata.gz: 6f45fbaf1de91fd1676d94063f6b8d34663207d0f81de84805eca6203789f6864fe48f54137a0cd73178fc7972f309dec9a3ef8bc956070ec09fd5bbac74c4e9
-  data.tar.gz: ff8f92d7ffe8f69d040d00237227c14696453abe76b3bdd90163ae2ffdc681bd0059ca119c6216a2f454f862fdd4db80196c2befa8c1e07b0c73a430fee5a06e
+  metadata.gz: 006cd9c4e3523f36e0077347546fd8a13934076209773bb8df796f8c04d5cdc2904d0e3431e1856bbb0a186eaaca8335eda9a3ba92f946e44eb7d88cea94a9a9
+  data.tar.gz: c067bfb41d203f00d75cd92e7c64017f77e0065f76fcdbf8dc08621ed0a5d14bc10d0a5c338ab47df3e665bd8471162e88cbfa6d888c4427995d66941e90e083

data/CHANGELOG.md

@@ -1,5 +1,97 @@
 # Changelog
 
+## [0.4.44] - 2026-10-30
+
+### Fixed
+- Preflight required Entry, Expertise, and AccessLog models before ingestion mutates data; unavailable deployments now log the missing components and return `apollo_data_not_available` without creating partial entries (#42).
+- Refuse semantic queries that cannot be audited before embedding, lookup, or confidence boosts; preserve non-audited traversal only for the `unknown` agent.
+- Require Relation persistence before bounded corroboration promotion; keep relation statistics optional when the relation model is unavailable.
+
+## [0.4.43] - 2026-10-30
+
+### Fixed
+- Commit entry creation or corroboration, expertise bookkeeping, and ingest access logging as one transaction; queue contradiction work only after commit (#41).
+- Roll back complete ingest state when any synchronous persistence side effect fails, including a corroboration confidence update.
+- Recover content-hash races through a nested savepoint only when a committed winner exists; otherwise return a truthful failure without partial data.
+
+## [0.4.42] - 2026-10-30
+
+### Fixed
+- Retain independently sourced candidate evidence during ingest and bootstrap exactly one fresh-store confirmation through the bounded corroboration checker (#40).
+- Snapshot pre-existing confirmations so a bootstrap-derived confirmation cannot promote its paired candidate on a later scan or duplicate the relation.
+- Preserve domain, type, access scope, provider, source-channel, private-owner, and team-membership corroboration boundaries during bootstrap.
+
+## [0.4.41] - 2026-10-30
+
+### Fixed
+- Execute service-side deprecation, force decay, stale archival, and dispute resolution while retaining no-data client action envelopes (#39).
+- Archive deprecated entries with retained reason/source metadata; make identical repeats idempotent and return truthful HTTP success, missing, unavailable, and persistence-failure responses.
+- Apply the approved dispute policy: `accept`/`keep` confirms, `reject` archives, and invalid or non-disputed decisions leave state unchanged. Persist lifecycle status and decision metadata atomically.
+- Keep force decay limited to confidence multiplication and use last-update-or-creation time for stale archival.
+- Handle bodyless API requests and pass explicit payload hashes to the JSON helper so health, validation, and unavailable-data responses remain JSON.
+
+## [0.4.40] - 2026-10-30
+
+### Fixed
+- Persist GAS synthesis through normal ingestion and report separate successful entry, failed entry, persisted relation, failed relation, and skipped relation counts (#38).
+- Resolve graph sources from successful fact IDs, including deduplicated entries; reject missing endpoints, self-links, cross-scope links, weak/unsupported edges, and duplicate edges within a batch.
+- Retain synthesis provenance for successfully stored sources and continue processing independent relations after a write failure.
+- Include the existing GAS `supports_by` and `extends` relation types in the traversal vocabulary.
+
+## [0.4.39] - 2026-10-29
+
+### Fixed
+- Load the GAS runner explicitly and return its module as the subscription receiver, so audit events call `Gas.process` instead of attempting to dispatch on a String (#37).
+
+## [0.4.38] - 2026-10-29
+
+### Fixed
+- Recognize research tools in canonical `Response.tools`, including typed tool objects and symbol/string-keyed hashes, when deciding whether to capture writeback (#36).
+- Preserve existing `tool_calls` and enrichment-based research detection; Apollo-only and non-research responses remain ineligible.
+
+## [0.4.37] - 2026-10-29
+
+### Fixed
+- Dispatch the contradiction scanner through its actual actor entry point and deliberately invoke the internal private detector (#35).
+- Snapshot pending work safely, continue after individual failures, and retain only failed items for a later scan.
+- Commit contradiction relations and disputed statuses atomically after LLM checks; database failures roll back and remain retryable.
+
+## [0.4.36] - 2026-10-29
+
+### Fixed
+- Declare all five Apollo exchange-to-queue bindings explicitly for the two-exchange topology instead of relying on single-exchange inference (#34).
+- Bind the GAS subscription even when its queue class is already loaded; repeated startup remains idempotent.
+
+## [0.4.35] - 2026-10-29
+
+### Fixed
+- Construct request query and ingest messages with keyword payloads so Ruby 3.4+ can publish them through the real transport classes (#33).
+- Check the transport connection's actual session state instead of calling an unavailable top-level `connected?` API.
+
+## [0.4.34] - 2026-10-29
+
+### Fixed
+- Scope ingestion and maintenance corroboration to matching domains, content types, access scopes, and eligible lifecycle states (#32).
+- Reuse query visibility rules for private ownership and shared-team membership; unresolved ownership cannot corroborate restricted knowledge.
+- Search past dependent sources instead of allowing the first same-source match to hide eligible independent evidence.
+
+## [0.4.33] - 2026-10-29
+
+### Fixed
+- Bind semantic-search and graph-traversal values through Sequel, including tags, statuses, domains, ownership, limits, confidence thresholds, and traversal depth (#31).
+- Bind vector literals and contradiction-query limits instead of interpolating values into SQL.
+
+## [0.4.32] - 2026-10-29
+
+### Fixed
+- Preserve usable writeback embeddings during ingestion instead of generating them again, allowing storage-only nodes to persist vectors without an embedding provider (#30).
+- Reject zero, nonnumeric, and nonfinite supplied vectors before persistence; retain the existing embedding fallback when no usable vector is supplied.
+
+## [0.4.31] - 2026-10-29
+
+### Fixed
+- Detect embedding capability through the provider-agnostic SSOT router lane rather than an Ollama-specific availability check.
+
 ## [0.4.30] - 2026-07-31
 
 ### Removed

data/README.md

@@ -69,25 +69,38 @@ client.agent_profile(agent_id: 'my-agent-001')
 ### Maintenance
 
 ```ruby
-# Force confidence decay cycle (factor multiplied against each entry's confidence)
+# Multiply each non-archived entry's confidence by the supplied factor
 client.force_decay(factor: 0.5)
 
-# Archive entries older than N days
+# Archive non-archived entries untouched for N days
 client.archive_stale(days: 90)
 
 # Resolve a corroboration dispute
 client.resolve_dispute(entry_id: 'entry-uuid', resolution: :accept)
 ```
 
+With a loaded Entry model, these methods execute against the service database and return persisted outcomes. Without local data, Ruby callers retain the existing action envelopes; these envelopes do not claim a successful mutation.
+
+- `deprecate_entry` archives the entry and preserves its other source metadata, storing the supplied reason as `source_context.deprecation_reason`. An identical repeat is a no-op.
+- `force_decay` accepts a finite factor from 0 through 1 and changes confidence only; it does not implicitly archive entries.
+- `archive_stale` accepts nonnegative days and uses `COALESCE(updated_at, created_at)` to determine staleness.
+- `resolve_dispute` accepts `:accept` or `:keep` to confirm a disputed entry, or `:reject` to archive it. It records `source_context.dispute_resolution`, sets `confirmed_at` when confirming, and preserves confidence. Unknown resolutions and non-disputed entries fail without mutation.
+
+The standalone deprecation endpoint returns HTTP 200 after success, 404 for a missing entry, 503 when local data is unavailable, and 500 when persistence fails. Lifecycle status and metadata changes commit together.
+
 ## Architecture
 
 ### Client Mode
 
-Runners build structured payloads and publish to the `apollo` exchange via RabbitMQ. No PostgreSQL or pgvector dependency is needed in the calling agent. Transport requires `Legion::Transport` to be loaded (the `if defined?(Legion::Transport)` guard in the entry point handles this automatically).
+Runners build structured payloads and publish to the `legion.apollo` exchange via RabbitMQ. No PostgreSQL or pgvector dependency is needed in the calling agent. Transport requires `Legion::Transport` to be loaded.
+
+Startup explicitly binds the ingest, query, writeback-store, and writeback-vectorize queues to `legion.apollo`, using each queue's name as its routing key. The `legion.apollo.gas` queue binds separately to `llm.audit` with routing key `llm.audit.complete`. Repeated startup preserves these bindings.
+
+Automatic writeback checks research tool calls in `Legion::LLM::Inference::Response#tools`, accepting typed tools and symbol/string-keyed hashes. Existing response `tool_calls` and enrichment-based tool history remain supported. Responses must meet the configured minimum content length; Apollo context alone does not qualify a response for capture.
 
 ### Service Mode
 
-Five actors run in the dedicated Apollo service process:
+Service actors include:
 
 | Actor | Type | Interval | Purpose |
 |---|---|---|---|
@@ -96,6 +109,29 @@ Five actors run in the dedicated Apollo service process:
 | `Decay` | Interval | 3600s | Confidence decay cycle across all entries |
 | `ExpertiseAggregator` | Interval | 1800s | Recalculate domain proficiency scores |
 | `CorroborationChecker` | Interval | 900s | Scan pending entries for auto-confirm threshold |
+| `GasSubscriber` | Subscription | on-message | Process `llm.audit.complete` events and persist accepted GAS outputs |
+
+### Atomic Ingestion
+
+After text embedding is complete, an ingest commits its Entry change (including a corroboration boost), expertise bookkeeping, and ingest access log in one database transaction. Contradiction scanning is queued only after that transaction commits. Failed entry, expertise, access-log, or corroboration-side-effect writes leave no partial row, confidence boost, or queued contradiction work.
+
+Content-hash uniqueness conflicts use a nested savepoint. If another transaction committed the winner, Apollo records against that winner; if no winner can be read after rollback, the ingest fails rather than reporting a nil or partial success.
+
+Apollo preflights Entry, Expertise, and AccessLog before ingestion writes anything; a missing required model rejects the request without a partial entry. Semantic queries require AccessLog before embedding, lookup, or confidence boosts so reads remain auditable. Traversal requires it only when a non-`unknown` agent causes an audit write. Relation remains optional for statistics, but corroboration does not promote a candidate unless it can persist the matching relation.
+
+### GAS Persistence
+
+GAS deposits facts and synthesis through normal Knowledge ingestion. New synthesis entries remain candidates and record their original source indices plus successfully stored source entry IDs in `source_context`; existing deduplicated entries retain their metadata.
+
+The `process` result's top-level counts describe generated phase outputs. Its `deposited` object reports storage outcomes:
+
+- `deposited`, `facts`, and `synthesis` count successful ingest results with entry IDs, including deduplication—not just newly inserted rows.
+- `failed` counts rejected or failed entry writes.
+- `relations`, `relations_failed`, and `relations_skipped` distinguish persisted edges, failed writes or missing endpoints, and intentionally skipped edges.
+
+Relations must meet the configured confidence gate, use a supported type, and connect an unambiguous successful fact deposit to an existing target in the same access scope. Self-links and duplicate edges within the batch are skipped. Independent relation failures do not discard successful entry deposits or prevent later edges from being processed. Existing GAS types `supports_by` and `extends` are also accepted by graph traversal.
+
+Relation deduplication is batch-local; repeated audit events are not an exactly-once delivery contract.
 
 ### GAIA Tick Integration
 
@@ -106,7 +142,8 @@ Apollo is wired into the GAIA tick cycle at the `knowledge_retrieval` phase (pha
 Entries have a confidence score between 0.0 and 1.0:
 
 - New entries start at `INITIAL_CONFIDENCE` (0.5) with status `candidate`
-- Corroboration from a semantically similar entry (cosine > 0.9) boosts confidence by 0.3 and promotes to `confirmed`
+- Ingestion corroborates confirmed evidence. The bounded periodic checker can bootstrap one confirmation from a pair of independently sourced candidates; it marks that confirmation as bootstrap-derived so its paired candidate does not confirm solely by seeing the new status on a later scan.
+- Corroboration stays within the same knowledge domain, content type, and access scope. Equal known providers and equal source channels are not independent. Private evidence requires the same resolved owner; team evidence requires shared identity-group membership. Unresolved private/team ownership does not corroborate.
 - Each retrieval adds a small boost (+0.02, capped at 1.0)
 - Confidence decays hourly by factor 0.998; entries below 0.1 are archived
 - The GAIA write gate (`meets_write_gate?`) requires confidence > 0.6 and novelty > 0.3 for the tick write-back path

data/lib/legion/extensions/apollo/actors/contradiction_scanner.rb

@@ -26,13 +26,11 @@ module Legion
             end
 
             def drain
-              items = []
-              items << queue.pop until queue.empty?
-              items
+              mutex.synchronize { Array.new(queue.size) { queue.pop(true) } }
             end
           end
 
-          def runner_class    = Legion::Extensions::Apollo::Runners::Knowledge
+          def runner_class    = self.class
           def runner_function = 'scan_pending_contradictions'
           def time            = settings[:actors][:contradiction_interval]
           def run_now?        = false
@@ -40,18 +38,23 @@ module Legion
           def check_subtask?  = false
           def generate_task?  = false
 
-          def every
+          def scan_pending_contradictions(**)
             items = self.class.drain
-            return if items.empty?
+            return { processed: 0, failed: 0 } if items.empty?
 
-            log.debug("Apollo ContradictionScanner.every processing=#{items.size}")
             runner = Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge)
+            processed = 0
+            failed = 0
             items.each do |item|
-              runner.detect_contradictions(item[:entry_id], item[:embedding], item[:content])
+              runner.send(:detect_contradictions, item[:entry_id], item[:embedding], item[:content])
+              processed += 1
+            rescue StandardError => e
+              self.class.enqueue(**item)
+              failed += 1
+              handle_exception(e, level: :error, operation: 'apollo.actor.contradiction_scanner', entry_id: item[:entry_id])
             end
-            log.info("Apollo ContradictionScanner.every completed=#{items.size}")
-          rescue StandardError => e
-            handle_exception(e, level: :error, operation: 'apollo.actor.contradiction_scanner')
+            log.info("Apollo ContradictionScanner.scan_pending_contradictions processed=#{processed} failed=#{failed}")
+            { processed: processed, failed: failed }
           end
         end
       end

data/lib/legion/extensions/apollo/actors/gas_subscriber.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/actors/subscription'
+require_relative '../runners/gas'
 
 module Legion
   module Extensions
     module Apollo
       module Actor
         class GasSubscriber < Legion::Extensions::Actors::Subscription
-          def runner_class    = 'Legion::Extensions::Apollo::Runners::Gas'
+          def runner_class    = Legion::Extensions::Apollo::Runners::Gas
           def runner_function = 'process'
           def check_subtask?  = false
           def generate_task?  = false
@@ -22,11 +23,8 @@ module Legion
           end
 
           def create_queue
-            return if queues.const_defined?(:GasSubscriber, false)
-
-            queues.const_set(:GasSubscriber, Apollo::Transport::Queues::GasSubscriber) unless queues.const_defined?(:GasSubscriber, false)
-            exchange_object = Apollo::Transport::Exchanges::LlmAudit.new
-            queue_object = Apollo::Transport::Queues::GasSubscriber.new
+            exchange_object = Legion::Extensions::Apollo::Transport::Exchanges::LlmAudit.new
+            queue_object = Legion::Extensions::Apollo::Transport::Queues::GasSubscriber.new
             queue_object.bind(exchange_object, routing_key: 'llm.audit.complete')
           end
         end

data/lib/legion/extensions/apollo/api.rb

@@ -51,13 +51,13 @@ module Legion
           include Legion::JSON::Helper
 
           def json_body
-            body = request.body.read
-            return {} if body.empty?
+            body = request.body&.read
+            return {} if body.nil? || body.empty?
 
             json_parse(body)
           rescue Legion::JSON::ParseError => e
             handle_exception(e, level: :warn, operation: 'apollo.api.json_body')
-            halt 400, json_dump(error: "invalid JSON: #{e.message}")
+            halt 400, json_dump({ error: "invalid JSON: #{e.message}" })
           end
 
           def runner
@@ -80,13 +80,13 @@ module Legion
         # Health check
         get '/api/apollo/health' do
           available = Helpers::DataModels.apollo_entry_available?
-          json_dump(status: available ? 'ok' : 'degraded', data_available: available)
+          json_dump({ status: available ? 'ok' : 'degraded', data_available: available })
         end
 
         # Query knowledge (semantic search)
         post '/api/apollo/query' do
           req = json_body
-          halt 400, json_dump(error: 'query is required') unless req[:query]
+          halt 400, json_dump({ error: 'query is required' }) unless req[:query]
 
           query_options = {
             query:          req[:query],
@@ -106,8 +106,8 @@ module Legion
         # Ingest knowledge
         post '/api/apollo/ingest' do
           req = json_body
-          halt 400, json_dump(error: 'content is required') unless req[:content]
-          halt 400, json_dump(error: 'content_type is required') unless req[:content_type]
+          halt 400, json_dump({ error: 'content is required' }) unless req[:content]
+          halt 400, json_dump({ error: 'content_type is required' }) unless req[:content_type]
 
           result = runner.handle_ingest(
             content:          req[:content],
@@ -126,7 +126,7 @@ module Legion
         # Graph traversal
         post '/api/apollo/traverse' do
           req = json_body
-          halt 400, json_dump(error: 'entry_id is required') unless req[:entry_id]
+          halt 400, json_dump({ error: 'entry_id is required' }) unless req[:entry_id]
 
           result = runner.handle_traverse(
             entry_id:       req[:entry_id],
@@ -141,7 +141,7 @@ module Legion
         # Retrieve relevant (GAIA-compatible)
         post '/api/apollo/retrieve' do
           req = json_body
-          halt 400, json_dump(error: 'query is required') unless req[:query]
+          halt 400, json_dump({ error: 'query is required' }) unless req[:query]
 
           result = runner.retrieve_relevant(
             query:          req[:query],
@@ -160,6 +160,16 @@ module Legion
             entry_id: params[:id],
             reason:   json_body[:reason] || 'deprecated via API'
           )
+          halt 503, json_dump({ success: false, error: 'apollo_data_not_available' }) if result[:action] == :deprecate
+
+          status_code = if result[:success]
+                          200
+                        elsif result[:error] == 'entry_not_found'
+                          404
+                        else
+                          500
+                        end
+          status status_code
           json_dump(result)
         end
 

data/lib/legion/extensions/apollo/helpers/capability.rb

@@ -8,15 +8,21 @@ module Legion
           extend Legion::Logging::Helper
           extend Legion::Settings::Helper
 
-          EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
           PRIVILEGE_MUTEX = Mutex.new
 
           module_function
 
+          # SSOT gate: the sole selection authority for embeddings is the
+          # router (Call::Embeddings.generate with no provider arg →
+          # Router.next_lane). can_embed? asks the one capability fact that
+          # matches that selection — is there an embedding-type lane the
+          # router can select? — against the same registry lanes the router
+          # reads. Provider-agnostic (no ollama pin, no hardcoded model
+          # list); no parallel settings-based "second domain".
           def can_embed?
             return false unless defined?(Legion::LLM) && Legion::LLM.started?
 
-            ollama_embedding_available? || cloud_embedding_configured?
+            Legion::LLM.can_embed?
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.capability.can_embed')
             false
@@ -39,24 +45,6 @@ module Legion
             false
           end
 
-          def ollama_embedding_available?
-            return false unless defined?(Legion::LLM::Discovery::Ollama)
-
-            EMBEDDING_MODELS.any? { |m| Legion::LLM::Discovery::Ollama.model_available?(m) }
-          rescue StandardError => e
-            handle_exception(e, level: :warn, operation: 'apollo.capability.ollama_embedding_available')
-            false
-          end
-
-          def cloud_embedding_configured?
-            provider = settings[:embedding][:provider]
-            model = settings[:embedding][:model]
-            !provider.nil? && !model.nil?
-          rescue StandardError => e
-            handle_exception(e, level: :warn, operation: 'apollo.capability.cloud_embedding_configured')
-            false
-          end
-
           def check_db_write_privilege
             PRIVILEGE_MUTEX.synchronize do
               return @apollo_write_privilege unless @apollo_write_privilege.nil?

data/lib/legion/extensions/apollo/helpers/confidence.rb

@@ -20,7 +20,7 @@ module Legion
           DECAY_MIN_AGE_HOURS = 168
           CONTENT_TYPES = %i[fact concept procedure association observation].freeze
           STATUSES = %w[candidate confirmed disputed decayed archived].freeze
-          RELATION_TYPES = %w[is_a has_a part_of causes similar_to contradicts supersedes depends_on].freeze
+          RELATION_TYPES = %w[is_a has_a part_of causes similar_to contradicts supersedes depends_on supports_by extends].freeze
 
           module_function
 

data/lib/legion/extensions/apollo/helpers/graph_query.rb

@@ -20,14 +20,8 @@ module Legion
           def default_query_limit          = settings[:query][:default_limit]
           def default_query_min_confidence = settings[:query][:default_min_confidence]
 
-          def build_traversal_sql(depth: default_depth, relation_types: nil, min_activation: self.min_activation, **)
-            sf = spread_factor
-            type_filter = if relation_types&.any?
-                            types = relation_types.map { |t| "'#{t}'" }.join(', ')
-                            "AND r.relation_type IN (#{types})"
-                          else
-                            ''
-                          end
+          def build_traversal_sql(relation_types: nil, **)
+            type_filter = relation_types&.any? ? 'AND r.relation_type IN :relation_types' : ''
 
             <<~SQL
               WITH RECURSIVE graph AS (
@@ -40,12 +34,12 @@ module Legion
 
                 SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
                        g.depth + 1,
-                       (g.activation * #{sf} * r.weight)::float
+                       (g.activation * :spread_factor * r.weight)::float
                 FROM graph g
                 JOIN apollo_relations r ON r.from_entry_id = g.id #{type_filter}
                 JOIN apollo_entries e ON e.id = r.to_entry_id
-                WHERE g.depth < #{depth}
-                  AND g.activation * #{sf} * r.weight > #{min_activation}
+                WHERE g.depth < :depth
+                  AND g.activation * :spread_factor * r.weight > :min_activation
               )
               SELECT DISTINCT ON (id) id, content, content_type, confidence, tags, source_agent,
                      depth, activation
@@ -54,51 +48,41 @@ module Legion
             SQL
           end
 
-          def build_semantic_search_sql(limit: default_query_limit, min_confidence: default_query_min_confidence,
-                                        statuses: nil, tags: nil, domain: nil,
-                                        requesting_principal_id: nil, **)
-            conditions = ["e.confidence >= #{min_confidence}"]
+          def build_semantic_search_sql(statuses: nil, tags: nil, domain: nil, requesting_principal_id: nil, **)
+            conditions = ['e.confidence >= :min_confidence']
+            conditions << 'e.status IN :statuses' if statuses&.any?
+            conditions << 'e.tags && CAST(:tags AS text[])' if tags&.any?
+            conditions << 'e.knowledge_domain = :domain' if domain
 
-            if statuses&.any?
-              status_list = statuses.map { |s| "'#{s}'" }.join(', ')
-              conditions << "e.status IN (#{status_list})"
-            end
-
-            if tags&.any?
-              tag_list = tags.map { |t| "'#{t}'" }.join(', ')
-              conditions << "e.tags && ARRAY[#{tag_list}]::text[]"
-            end
-
-            conditions << "e.knowledge_domain = '#{domain}'" if domain
-
-            if requesting_principal_id
-              pid = requesting_principal_id.to_i
-              conditions << <<~SCOPE_SQL.strip
-                (e.access_scope = 'global'
-                 OR (e.access_scope = 'private'
-                     AND (e.identity_principal_id = #{pid}
-                          OR e.identity_id IN (SELECT id FROM identities WHERE principal_id = #{pid})))
-                 OR (e.access_scope = 'team'
-                     AND EXISTS (
-                       SELECT 1 FROM identity_group_memberships igm1
-                       JOIN identity_group_memberships igm2 ON igm1.group_id = igm2.group_id
-                       WHERE igm1.principal_id = #{pid}
-                         AND igm2.principal_id = e.identity_principal_id
-                     )))
-              SCOPE_SQL
-            end
+            conditions << access_scope_sql if requesting_principal_id
 
             where_clause = conditions.join(' AND ')
 
             <<~SQL
               SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
                      e.access_count, e.created_at, e.knowledge_domain,
-                     (e.embedding <=> :embedding) AS distance
+                     (e.embedding <=> CAST(:embedding AS vector)) AS distance
               FROM apollo_entries e
               WHERE #{where_clause}
                 AND e.embedding IS NOT NULL
-              ORDER BY e.embedding <=> :embedding
-              LIMIT #{limit}
+              ORDER BY e.embedding <=> CAST(:embedding AS vector)
+              LIMIT :limit
+            SQL
+          end
+
+          def access_scope_sql
+            <<~SQL
+              (access_scope = 'global'
+               OR (access_scope = 'private'
+                   AND (identity_principal_id = :requesting_principal_id
+                        OR identity_id IN (SELECT id FROM identities WHERE principal_id = :requesting_principal_id)))
+               OR (access_scope = 'team'
+                   AND EXISTS (
+                     SELECT 1 FROM identity_group_memberships igm1
+                     JOIN identity_group_memberships igm2 ON igm1.group_id = igm2.group_id
+                     WHERE igm1.principal_id = :requesting_principal_id
+                       AND igm2.principal_id = identity_principal_id
+                   )))
             SQL
           end
         end

data/lib/legion/extensions/apollo/helpers/writeback.rb

@@ -31,16 +31,10 @@ module Legion
             content = response_content(response)
             return false if content.nil? || content.length < min_content_length
 
-            tool_calls = extract_tool_calls(response, enrichments)
-            research_calls = tool_calls.select { |tc| RESEARCH_TOOLS.include?(tc[:name] || tc['name']) }
-
-            return false if research_calls.empty?
-
-            apollo_results = enrichments['rag_context:apollo_results']
-            return true if apollo_results.nil? || (apollo_results[:count] || 0).zero?
-
-            # Apollo had results — only capture if LLM also did additional research
-            research_calls.any?
+            extract_tool_calls(response, enrichments).any? do |call|
+              name = call.respond_to?(:name) ? call.name : call[:name] || call['name']
+              RESEARCH_TOOLS.include?(name)
+            end
           end
 
           def build_payload(request:, response:, source_channel: nil)
@@ -147,9 +141,11 @@ module Legion
 
           def extract_tool_calls(response, enrichments)
             calls = []
-            calls += Array(response.tool_calls) if response.respond_to?(:tool_calls)
-            calls += Array(enrichments['tool_calls']) if enrichments['tool_calls']
-            calls.uniq { |tc| tc[:name] || tc['name'] }
+            calls.concat(Array(response.tools)) if response.respond_to?(:tools)
+            calls.concat(Array(response.tool_calls)) if response.respond_to?(:tool_calls)
+            calls.concat(Array(enrichments['tool_calls'])) if enrichments['tool_calls']
+            calls.uniq! { |call| call.respond_to?(:name) ? call.name : call[:name] || call['name'] }
+            calls
           end
 
           def derive_tags(query)