lex-microsoft_teams 0.6.10 → 0.6.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e42be4e2705458e0553a5ddda3ffc23eb02306dbc151bbb0b8eaa5b3843292b9
-  data.tar.gz: eeef160d8547d2ccfeaa15be4a9752105b4a057f5c2f44b42a3e2f0fc6731a82
+  metadata.gz: 7e4252f4382060712bb112a7d7beaf55b10947fe6200185a3fb6ee413e4f3927
+  data.tar.gz: af5fb381e122efd02feab899a484242c71f5b67fb620717fad6dcb12c372e2cd
 SHA512:
-  metadata.gz: 1ec79f9ea87a935bdf9d53b825040bc487e56c540f4b230bca4d76f196e12372b3cee9a316395d279a65dbdf93237645d1855f0f2bec1ad052a6aa63736677e2
-  data.tar.gz: 04f084a840374730ac6394990d3c4c6ce74973706e23bd9631fcd1fd03014ab905570036be5c807c31c72cfdb8e96e486a52ccd95109ca2ce7b580e7abfa3137
+  metadata.gz: 22a8726642d3a8209c09c4fc797812825cd21ae7dcc8818438333a62291fa9a3a08356125e5003a426e8098ba56ad8033e77a1fd0bb4a162bd6c989bd20b127d
+  data.tar.gz: 89f55fcbe2210cc4f55a77d4ee04407fe0a3ba437cb1ad14e4699468f0dfbdcf1481ae72d01f230305c0ded9c9e2b1a1558360502ae43a27428d9f5d72634377

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.6.14] - 2026-03-23
+
+### Added
+- Graph API ingest runner and actor for fetching top contacts and their 1:1 chat messages
+- People-based chat matching with email, userId, and displayName fallbacks
+- High-water mark support for incremental message fetching
+- Paginated chat fetching with MAX_CHAT_PAGES cap
+
+### Changed
+- Replace all silent rescue blocks with log.debug/warn/error entries
+- Use `log.` helper consistently instead of `Legion::Logging.`
+- Fix `IncrementalSync#resolve_token` to use `TokenCache.instance` instead of `.new`
+- Clean up debug logging (remove log.unknown/log.fatal, use log.debug)
+
+## [0.6.13] - 2026-03-22
+
+### Changed
+- Add legion-data, legion-json, and legion-transport as runtime dependencies
+- Include `Legion::Data::Helper`, `Legion::JSON::Helper`, and `Legion::Transport::Helper` in spec_helper Lex stub
+
+## [0.6.12] - 2026-03-22
+
+### Changed
+- Add legion-cache and legion-crypt as runtime dependencies
+- Include `Legion::Cache::Helper` and `Legion::Crypt::Helper` in spec_helper Lex stub
+
+## [0.6.11] - 2026-03-22
+
+### Changed
+- Add legion-logging and legion-settings as runtime dependencies
+- Include `Legion::Settings::Helper` in spec_helper Lex stub for real settings access in tests
+
 ## [0.6.10] - 2026-03-22
 
 ### Changed

data/Gemfile

@@ -4,7 +4,6 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'legion-logging', '>= 1.3.2'
   gem 'rake'
   gem 'rspec'
   gem 'rspec_junit_formatter'

data/lex-microsoft_teams.gemspec

@@ -28,5 +28,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'base64', '>= 0.1'
   spec.add_dependency 'faraday', '>= 2.0'
+  spec.add_dependency 'legion-cache', '>= 1.3.11'
+  spec.add_dependency 'legion-crypt', '>= 1.4.9'
+  spec.add_dependency 'legion-data', '>= 1.4.17'
+  spec.add_dependency 'legion-json', '>= 1.2.1'
+  spec.add_dependency 'legion-logging', '>= 1.3.2'
+  spec.add_dependency 'legion-settings', '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
   spec.add_dependency 'snappy', '>= 0.5'
 end

data/lib/legion/extensions/microsoft_teams/actors/api_ingest.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class ApiIngest < Legion::Extensions::Actors::Every
+          def runner_class = Legion::Extensions::MicrosoftTeams::Runners::ApiIngest
+
+          def runner_function = 'ingest_api'
+
+          def use_runner? = false
+
+          def check_subtask? = false
+
+          def generate_task? = false
+
+          def run_now? = true
+
+          def delay
+            10.0 # let memory + cache ingest initialize first
+          end
+
+          def time
+            interval = teams_settings.dig(:ingest, :api_interval) || 1800
+            interval.to_i
+          end
+
+          def enabled?
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          rescue StandardError => e
+            log.warn("ApiIngest#enabled?: #{e.message}")
+            false
+          end
+
+          def manual
+            token = resolve_token
+            unless token
+              log.warn('ApiIngest: no delegated token, skipping')
+              return
+            end
+
+            ingest = teams_settings[:ingest] || {}
+            log.info('ApiIngest: starting Graph API ingest')
+            result = runner_class.ingest_api(
+              token:          token,
+              top_people:     ingest.fetch(:top_people, 15),
+              message_depth:  ingest.fetch(:message_depth, 50),
+              skip_bots:      ingest.fetch(:skip_bots, true),
+              imprint_active: imprint_active?
+            )
+            log.info("ApiIngest: #{result.inspect[0, 200]}")
+            result
+          rescue StandardError => e
+            log.error("ApiIngest: #{e.message}")
+          end
+
+          private
+
+          def token_available?
+            resolve_token != nil
+          end
+
+          def resolve_token
+            if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+              Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
+            end
+          rescue StandardError => e
+            log.warn("ApiIngest#resolve_token: #{e.message}")
+            nil
+          end
+
+          def teams_settings
+            return {} unless defined?(Legion::Settings)
+
+            Legion::Settings[:microsoft_teams] || {}
+          rescue StandardError => e
+            log.warn("ApiIngest#teams_settings: #{e.message}")
+            {}
+          end
+
+          def imprint_active?
+            return false unless defined?(Legion::Extensions::Coldstart::Helpers::Bootstrap)
+
+            Legion::Extensions::Coldstart::Helpers::Bootstrap.new.imprint_active?
+          rescue StandardError => e
+            log.debug("ApiIngest#imprint_active?: #{e.message}")
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/actors/auth_validator.rb

@@ -15,7 +15,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("AuthValidator#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/cache_bulk_ingest.rb

@@ -17,7 +17,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("CacheBulkIngest#enabled?: #{e.message}")
             false
           end
 
@@ -40,7 +41,8 @@ module Legion
             return false unless defined?(Legion::Extensions::Coldstart::Helpers::Bootstrap)
 
             Legion::Extensions::Coldstart::Helpers::Bootstrap.new.imprint_active?
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("CacheBulkIngest#imprint_active?: #{e.message}")
             false
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/cache_sync.rb

@@ -24,7 +24,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("CacheSync#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/channel_poller.rb

@@ -38,7 +38,8 @@ module Legion
             return false unless defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
 
             channel_setting(:enabled, false) == true
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ChannelPoller#enabled?: #{e.message}")
             false
           end
 
@@ -157,7 +158,8 @@ module Legion
             return default unless defined?(Legion::Settings)
 
             Legion::Settings.dig(:microsoft_teams, :channels, key) || default
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ChannelPoller#channel_setting(#{key}): #{e.message}")
             default
           end
 

data/lib/legion/extensions/microsoft_teams/actors/direct_chat_poller.rb

@@ -28,7 +28,8 @@ module Legion
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Runners::Bot) &&
               defined?(Legion::Transport)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("DirectChatPoller#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/incremental_sync.rb

@@ -15,7 +15,8 @@ module Legion
           def delay
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
-            rescue StandardError
+            rescue StandardError => e
+              log.debug("IncrementalSync#delay: #{e.message}")
               {}
             end
             settings.dig(:ingest, :incremental_interval) || 900
@@ -24,7 +25,8 @@ module Legion
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces) &&
               token_available?
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("IncrementalSync#enabled?: #{e.message}")
             false
           end
 
@@ -55,10 +57,10 @@ module Legion
 
           def resolve_token
             if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-              cache = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
-              cache.cached_delegated_token
+              Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
             end
-          rescue StandardError
+          rescue StandardError => e
+            log.warn("IncrementalSync#resolve_token: #{e.message}")
             nil
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/meeting_ingest.rb

@@ -24,7 +24,8 @@ module Legion
           def time
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
-            rescue StandardError
+            rescue StandardError => e
+              log.debug("MeetingIngest#time: #{e.message}")
               {}
             end
             settings.dig(:meetings, :ingest_interval) || DEFAULT_INGEST_INTERVAL
@@ -32,7 +33,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("MeetingIngest#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/message_processor.rb

@@ -13,7 +13,8 @@ module Legion
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Runners::Bot) &&
               defined?(Legion::Transport)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("MessageProcessor#enabled?: #{e.message}")
             false
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/observed_chat_poller.rb

@@ -30,7 +30,8 @@ module Legion
             return false unless defined?(Legion::Settings)
 
             Legion::Settings.dig(:microsoft_teams, :bot, :observe, :enabled) == true
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ObservedChatPoller#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/presence_poller.rb

@@ -24,7 +24,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("PresencePoller#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/actors/profile_ingest.rb

@@ -18,7 +18,8 @@ module Legion
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces) &&
               token_available?
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ProfileIngest#enabled?: #{e.message}")
             false
           end
 
@@ -33,7 +34,8 @@ module Legion
 
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
-            rescue StandardError
+            rescue StandardError => e
+              log.debug("ProfileIngest#manual settings: #{e.message}")
               {}
             end
             ingest = settings[:ingest] || {}
@@ -56,7 +58,8 @@ module Legion
             if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
               Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
             end
-          rescue StandardError
+          rescue StandardError => e
+            log.warn("ProfileIngest#resolve_token: #{e.message}")
             nil
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/token_refresher.rb

@@ -24,7 +24,8 @@ module Legion
 
           def enabled?
             defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("TokenRefresher#enabled?: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/cli/auth.rb

@@ -68,7 +68,8 @@ module Legion
             return {} unless defined?(Legion::Settings)
 
             Legion::Settings[:microsoft_teams]&.dig(:auth) || {}
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("Auth: resolve_settings failed: #{e.message}")
             {}
           end
 

data/lib/legion/extensions/microsoft_teams/helpers/high_water_mark.rb

@@ -58,7 +58,8 @@ module Legion
             return nil unless raw
 
             raw.is_a?(Hash) ? raw : ::JSON.parse(raw, symbolize_names: true)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("HighWaterMark: get_extended_hwm failed to parse cached value: #{e.message}")
             nil
           end
 

data/lib/legion/extensions/microsoft_teams/helpers/prompt_resolver.rb

@@ -51,7 +51,8 @@ module Legion
 
             profile = Legion::Extensions::Mesh::Helpers::PreferenceProfile.resolve(owner_id: owner_id)
             Legion::Extensions::Mesh::Helpers::PreferenceProfile.preference_instructions(profile: profile)
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("PromptResolver: preference_instructions_for failed: #{e.message}") if defined?(log)
             nil
           end
         end

data/lib/legion/extensions/microsoft_teams/helpers/token_cache.rb

@@ -25,7 +25,7 @@ module Legion
               @instance ||= begin
                 cache = new
                 cache.load_from_vault
-                Legion::Logging.info('[Teams::TokenCache] Shared instance created and loaded') if defined?(Legion::Logging)
+                log.info('[Teams::TokenCache] Shared instance created and loaded')
                 cache
               end
             end
@@ -249,7 +249,8 @@ module Legion
             enabled = Legion::Settings.dig(:crypt, :vault, :enabled) == true
             log.debug("vault_available? => #{enabled}")
             enabled
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("TokenCache: vault_available? check failed: #{e.message}")
             false
           end
 

data/lib/legion/extensions/microsoft_teams/runners/api_ingest.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'digest'
+require 'legion/extensions/microsoft_teams/helpers/client'
+require 'legion/extensions/microsoft_teams/helpers/permission_guard'
+require 'legion/extensions/microsoft_teams/helpers/high_water_mark'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module ApiIngest
+          include Helpers::Client
+          include Helpers::PermissionGuard
+          include Helpers::HighWaterMark
+          extend self
+
+          # Fetch top contacts via /me/people, then pull recent messages from
+          # their 1:1 chats. Stores each message as an individual memory trace
+          # (same format as CacheIngest) with dedup by content hash.
+          #
+          # Requires a delegated token with Chat.Read and People.Read scopes.
+          def ingest_api(token:, top_people: 15, message_depth: 50, skip_bots: true, imprint_active: false, **) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+            return error_result('lex-memory not loaded') unless memory_available?
+            return error_result('no token provided') unless token && !token.empty?
+
+            people = fetch_top_people(token: token, top: top_people)
+            log.debug("ApiIngest: fetched #{people.size} top people")
+            return error_result('people endpoint denied or empty') if people.empty?
+
+            chats = fetch_one_on_one_chats(token: token)
+            log.debug("ApiIngest: fetched #{chats.size} oneOnOne chats")
+            return error_result('no 1:1 chats found') if chats.empty?
+
+            existing_hashes = load_existing_hashes
+            conn = graph_connection(token: token)
+            stored = 0
+            skipped = 0
+            people_ingested = 0
+            thread_groups = Hash.new { |h, k| h[k] = [] }
+
+            people.each do |person|
+              chat = match_chat_to_person(chats: chats, person: person, conn: conn)
+              unless chat
+                log.debug("ApiIngest: no chat match for #{person['displayName']} " \
+                          "(email=#{person.dig('scoredEmailAddresses', 0, 'address')}, id=#{person['id']})")
+                next
+              end
+              log.info("ApiIngest: matched #{person['displayName']} to chat #{chat['id']}")
+
+              messages = fetch_chat_messages(conn: conn, chat_id: chat['id'], depth: message_depth)
+              next if messages.empty?
+
+              msg_stored = 0
+              messages.each do |msg|
+                next if skip_bots && bot_message_graph?(msg)
+
+                text = extract_body_text(msg)
+                next if text.length < 5
+
+                content_hash = msg['id'] || Digest::SHA256.hexdigest(text)[0, 16]
+                if existing_hashes.include?(content_hash)
+                  skipped += 1
+                  next
+                end
+
+                trace_result = store_graph_message(msg, text, person, chat['id'],
+                                                   content_hash:   content_hash,
+                                                   imprint_active: imprint_active)
+                if trace_result
+                  stored += 1
+                  msg_stored += 1
+                  existing_hashes << content_hash
+                  thread_groups[chat['id']] << trace_result[:trace_id]
+                else
+                  skipped += 1
+                end
+              end
+
+              next unless msg_stored.positive?
+
+              people_ingested += 1
+              update_extended_hwm(chat_id: chat['id'],
+                                  last_message_at: messages.map { |m| m['createdDateTime'] }.compact.max,
+                                  new_message_count: msg_stored, ingested: true)
+            end
+
+            coactivate_thread_traces(thread_groups)
+            flush_trace_store if stored.positive?
+
+            { result: { stored: stored, skipped: skipped, people_ingested: people_ingested,
+                        people_found: people.length, chats_found: chats.length } }
+          rescue StandardError => e
+            log_msg = "ApiIngest failed: #{e.class} — #{e.message}"
+            log.error(log_msg)
+            { result: { stored: stored || 0, skipped: skipped || 0, error: e.message } }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          MAX_CHAT_PAGES = 10
+
+          private
+
+          def fetch_top_people(token:, top:)
+            return [] if permission_denied?('/me/people')
+
+            conn = graph_connection(token: token)
+            resp = conn.get('me/people', { '$top' => top })
+
+            log.debug("ApiIngest: fetch_top_people status=#{resp.status} count=#{(resp.body || {}).fetch('value', []).size}")
+            if resp.status == 403
+              record_denial('/me/people', resp.body.dig('error', 'message') || 'Forbidden')
+              return []
+            end
+
+            people = (resp.body || {}).fetch('value', [])
+            people.sort_by { |p| -(p.dig('scoredEmailAddresses', 0, 'relevanceScore') || 0) }
+          rescue StandardError => e
+            log.warn("ApiIngest: fetch_top_people failed: #{e.message}")
+            []
+          end
+
+          def fetch_one_on_one_chats(token:)
+            conn = graph_connection(token: token)
+            all_chats = []
+            url = 'me/chats'
+            params = { '$top' => 50 }
+            pages = 0
+
+            loop do
+              resp = conn.get(url, params)
+              body = resp.body || {}
+              chats = body.fetch('value', [])
+              all_chats.concat(chats)
+              pages += 1
+
+              next_link = body['@odata.nextLink']
+              break unless next_link
+              break if pages >= MAX_CHAT_PAGES
+
+              url = next_link
+              params = {}
+            end
+
+            one_on_one = all_chats.select { |c| c['chatType'] == 'oneOnOne' }
+            log.info("ApiIngest: fetched #{all_chats.size} chats (#{pages} pages), #{one_on_one.size} oneOnOne")
+            one_on_one
+          rescue StandardError => e
+            log.warn("ApiIngest: fetch_chats failed: #{e.message}")
+            []
+          end
+
+          def match_chat_to_person(chats:, person:, conn:)
+            email = person.dig('scoredEmailAddresses', 0, 'address')&.downcase
+            display_name = person['displayName']&.downcase
+            user_id = person['id']
+            return nil unless email || user_id || display_name
+
+            chats.find do |chat|
+              members_resp = conn.get("chats/#{chat['id']}/members")
+              members = (members_resp.body || {}).fetch('value', [])
+              members.any? do |m|
+                match_member?(m, email: email, user_id: user_id, display_name: display_name)
+              end
+            end
+          rescue StandardError => e
+            log.debug("ApiIngest: match_chat_to_person failed: #{e.message}")
+            nil
+          end
+
+          def match_member?(member, email:, user_id:, display_name:)
+            return true if email && member['email']&.downcase == email
+            return true if user_id && member['userId'] == user_id
+            return true if email && member.dig('additionalData', 'email')&.downcase == email
+
+            member_name = member['displayName']&.downcase
+            return true if display_name && member_name && member_name == display_name
+
+            false
+          end
+
+          def fetch_chat_messages(conn:, chat_id:, depth: 50)
+            hwm = get_extended_hwm(chat_id: chat_id)
+            params = { '$top' => depth, '$orderby' => 'createdDateTime desc' }
+            params['$filter'] = "createdDateTime gt #{hwm[:last_message_at]}" if hwm&.dig(:last_message_at)
+
+            resp = conn.get("chats/#{chat_id}/messages", params)
+            log.debug("ApiIngest: fetch_messages chat=#{chat_id} count=#{(resp.body || {}).fetch('value', []).size}")
+            (resp.body || {}).fetch('value', [])
+          rescue StandardError => e
+            log.warn("ApiIngest: fetch_messages failed for #{chat_id}: #{e.message}")
+            []
+          end
+
+          def extract_body_text(msg)
+            html = msg.dig('body', 'content') || ''
+            strip_html(html)
+          end
+
+          def strip_html(html)
+            return '' if html.nil? || html.empty?
+
+            html.gsub(/<[^>]+>/, ' ').gsub('&nbsp;', ' ').gsub('&amp;', '&')
+                .gsub('&lt;', '<').gsub('&gt;', '>').gsub('&quot;', '"')
+                .gsub(/\s+/, ' ').strip
+          end
+
+          def bot_message_graph?(msg)
+            app = msg.dig('from', 'application')
+            return true if app && app['id']
+
+            user_type = msg.dig('from', 'user', 'userIdentityType')
+            %w[anonymousGuest azureCommunicationServicesUser].include?(user_type)
+          end
+
+          def store_graph_message(msg, text, person, chat_id, content_hash:, imprint_active: false)
+            sender = msg.dig('from', 'user', 'displayName') || person['displayName'] || 'Unknown'
+            compose_time = msg['createdDateTime']
+
+            domain_tags = build_graph_domain_tags(sender: sender, chat_id: chat_id,
+                                                  compose_time: compose_time, content_hash: content_hash,
+                                                  message_id: msg['id'])
+
+            memory_runner.store_trace(
+              type:                :episodic,
+              content_payload:     text,
+              domain_tags:         domain_tags,
+              origin:              :direct_experience,
+              confidence:          0.7,
+              emotional_valence:   0.1,
+              emotional_intensity: 0.2,
+              imprint_active:      imprint_active
+            )
+          rescue StandardError => e
+            log.warn("ApiIngest: store trace failed: #{e.message}")
+            nil
+          end
+
+          def build_graph_domain_tags(sender:, chat_id:, compose_time:, content_hash:, message_id:)
+            tags = %w[teams graph_api]
+            tags << "sender:#{sender}"
+            tags << "peer:#{sender}"
+            tags << "chat_id:#{chat_id}" if chat_id
+            tags << "hash:#{content_hash}" if content_hash
+            tags << "time:#{compose_time}" if compose_time
+            tags << "msg_id:#{message_id}" if message_id
+            tags
+          end
+
+          def load_existing_hashes
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
+            hashes = Set.new
+            store.all_traces(min_strength: 0.0).each do |trace|
+              trace[:domain_tags]&.each do |tag|
+                hashes << tag.delete_prefix('hash:') if tag.start_with?('hash:')
+              end
+            end
+            hashes
+          rescue StandardError => e
+            log.debug("ApiIngest: load_existing_hashes failed: #{e.message}")
+            Set.new
+          end
+
+          def memory_available?
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          end
+
+          def memory_runner
+            @memory_runner ||= Object.new.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          end
+
+          def flush_trace_store
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
+            store.flush if store.respond_to?(:flush)
+          rescue StandardError => e
+            log.warn("ApiIngest: flush failed: #{e.message}")
+          end
+
+          def coactivate_thread_traces(thread_groups)
+            return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Helpers::Store)
+
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
+            thread_groups.each_value do |trace_ids|
+              next if trace_ids.length < 2
+
+              trace_ids.each_cons(2) do |id_a, id_b|
+                store.record_coactivation(id_a, id_b)
+              rescue StandardError => e
+                log.debug("ApiIngest: coactivation link failed for #{id_a}/#{id_b}: #{e.message}")
+                nil
+              end
+            end
+          rescue StandardError => e
+            log.debug("ApiIngest: coactivation skipped: #{e.message}")
+          end
+
+          def error_result(message)
+            { result: { stored: 0, skipped: 0, error: message } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/runners/cache_ingest.rb

@@ -42,6 +42,7 @@ module Legion
             end
 
             coactivate_thread_traces(thread_groups)
+            flush_trace_store if stored.positive?
 
             { result: { stored: stored, skipped: skipped, latest_time: latest_time } }
           end
@@ -87,7 +88,10 @@ module Legion
 
           def build_domain_tags(msg)
             tags = ['teams']
-            tags << "sender:#{msg.sender}" if msg.sender
+            if msg.sender
+              tags << "sender:#{msg.sender}"
+              tags << "peer:#{msg.sender}"
+            end
             tags << "thread:#{msg.thread_topic}" if msg.thread_topic
             tags << "thread_id:#{msg.thread_id}" if msg.thread_id
             tags << "thread_type:#{msg.thread_type}" if msg.thread_type
@@ -97,17 +101,25 @@ module Legion
             tags
           end
 
+          def flush_trace_store
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
+            store.flush if store.respond_to?(:flush)
+          rescue StandardError => e
+            log.warn("CacheIngest: flush failed: #{e.message}")
+          end
+
           # Seed Hebbian coactivation links between messages in the same thread.
           def coactivate_thread_traces(thread_groups)
             return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Helpers::Store)
 
-            store = Legion::Extensions::Agentic::Memory::Trace::Helpers::Store.new
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
             thread_groups.each_value do |trace_ids|
               next if trace_ids.length < 2
 
               trace_ids.each_cons(2) do |id_a, id_b|
                 store.record_coactivation(id_a, id_b)
-              rescue StandardError
+              rescue StandardError => e
+                log.debug("CacheIngest: coactivation link failed for #{id_a}/#{id_b}: #{e.message}")
                 nil
               end
             end

data/lib/legion/extensions/microsoft_teams/runners/profile_ingest.rb

@@ -198,7 +198,8 @@ module Legion
               members = (members_resp.body || {}).fetch('value', [])
               members.any? { |m| m['email']&.downcase == email.downcase }
             end
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ProfileIngest: find_chat_for_person failed: #{e.message}")
             nil
           end
 
@@ -209,7 +210,8 @@ module Legion
 
             resp = conn.get("chats/#{chat_id}/messages", params)
             (resp.body || {}).fetch('value', [])
-          rescue StandardError
+          rescue StandardError => e
+            log.warn("ProfileIngest: fetch_new_messages failed for #{chat_id}: #{e.message}")
             []
           end
 
@@ -229,7 +231,8 @@ module Legion
             elsif defined?(Legion::LLM)
               Legion::LLM.ask(prompt: "#{definition[:prompt]}\n\nConversation with #{peer_name}:\n#{text}")
             end
-          rescue StandardError
+          rescue StandardError => e
+            log.debug("ProfileIngest: extract_conversation failed: #{e.message}")
             nil
           end
 

data/lib/legion/extensions/microsoft_teams/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.10'
+      VERSION = '0.6.14'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -20,6 +20,7 @@ require 'legion/extensions/microsoft_teams/runners/cache_ingest'
 require 'legion/extensions/microsoft_teams/runners/people'
 require 'legion/extensions/microsoft_teams/runners/profile_ingest'
 require 'legion/extensions/microsoft_teams/runners/ownership'
+require 'legion/extensions/microsoft_teams/runners/api_ingest'
 
 # Helpers (bot)
 require 'legion/extensions/microsoft_teams/helpers/high_water_mark'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.6.14
 platform: ruby
 authors:
 - Esity
@@ -37,6 +37,104 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
 - !ruby/object:Gem::Dependency
   name: snappy
   requirement: !ruby/object:Gem::Requirement
@@ -75,6 +173,7 @@ files:
 - docs/plans/2026-03-19-teams-token-lifecycle-implementation.md
 - lex-microsoft_teams.gemspec
 - lib/legion/extensions/microsoft_teams.rb
+- lib/legion/extensions/microsoft_teams/actors/api_ingest.rb
 - lib/legion/extensions/microsoft_teams/actors/auth_validator.rb
 - lib/legion/extensions/microsoft_teams/actors/cache_bulk_ingest.rb
 - lib/legion/extensions/microsoft_teams/actors/cache_sync.rb
@@ -105,6 +204,7 @@ files:
 - lib/legion/extensions/microsoft_teams/local_cache/sstable_reader.rb
 - lib/legion/extensions/microsoft_teams/runners/adaptive_cards.rb
 - lib/legion/extensions/microsoft_teams/runners/ai_insights.rb
+- lib/legion/extensions/microsoft_teams/runners/api_ingest.rb
 - lib/legion/extensions/microsoft_teams/runners/auth.rb
 - lib/legion/extensions/microsoft_teams/runners/bot.rb
 - lib/legion/extensions/microsoft_teams/runners/cache_ingest.rb