claude_memory 0.12.0 → 0.13.0

data/lib/claude_memory/observe/reflector.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Observe
+    # Deterministic, free (no LLM) Reflector for the episodic observation log.
+    #
+    # Runs inside Sweep, which fires on PreCompact and SessionEnd — Claude
+    # Code's context-pressure lifecycle events. That is the analog of Mastra's
+    # token-threshold-triggered reflection: "reflect when memory gets big" maps
+    # onto "reflect when the session is about to compact", without a wall-clock
+    # timer (Claude Code has no cron hook) and without extra API cost.
+    #
+    # Two passes, both provenance-preserving (tombstone, never hard-delete):
+    #   - dedupe: collapse near-identical active observations (same scope,
+    #     normalized body) into the newest, linking losers via consolidated_into.
+    #   - expire_stale_info: retire info-level (🟢 / priority 3) observations
+    #     older than the TTL to bound context size. Important (🔴) and maybe
+    #     (🟡) are never expired — only the lowest-signal tier ages out.
+    #
+    # Semantic consolidation ("combine related items, surface patterns") is
+    # deliberately NOT here — it needs the LLM and lands in the Phase-4
+    # Claude-as-reflector pass. This pass is pure Ruby so it can run shell-side
+    # in the sweep hook for free.
+    class Reflector
+      DEFAULT_INFO_TTL_DAYS = 30
+
+      # @return [Struct] counts from one reflection pass
+      Result = Struct.new(:deduped, :expired) do
+        def total
+          deduped + expired
+        end
+      end
+
+      def initialize(store, info_ttl_days: DEFAULT_INFO_TTL_DAYS)
+        @store = store
+        @info_ttl_days = info_ttl_days
+      end
+
+      # @return [Result] number of observations deduped and expired
+      def reflect!
+        deduped = 0
+        expired = 0
+        @store.db.transaction do
+          deduped = dedupe
+          expired = expire_stale_info
+        end
+        Result.new(deduped: deduped, expired: expired)
+      end
+
+      private
+
+      def dedupe
+        active = @store.observations.where(status: "active").order(:id).all
+        merged = 0
+
+        active.group_by { |o| [o[:scope], normalize(o[:body])] }.each_value do |rows|
+          next if rows.size < 2
+
+          keeper = rows.max_by { |r| [r[:observed_at].to_s, r[:id]] }
+          rows.each do |loser|
+            next if loser[:id] == keeper[:id]
+            # Fold the loser's sightings into the keeper before tombstoning so
+            # corroboration survives consolidation and can cross the promotion
+            # threshold. A duplicate IS a repeated sighting.
+            @store.increment_corroboration(keeper[:id], by: loser[:corroboration_count] || 1)
+            @store.tombstone_observation(loser[:id], into_id: keeper[:id])
+            merged += 1
+          end
+        end
+
+        merged
+      end
+
+      def expire_stale_info
+        cutoff = (Time.now - @info_ttl_days * 86400).utc.iso8601
+        ids = @store.observations
+          .where(status: "active", priority: Domain::Observation::INFO)
+          .where { observed_at < cutoff }
+          .select(:id)
+          .map { |r| r[:id] }
+
+        ids.each { |id| @store.expire_observation(id) }
+        ids.size
+      end
+
+      def normalize(body)
+        body.to_s.downcase.gsub(/\s+/, " ").strip
+      end
+    end
+  end
+end

data/lib/claude_memory/publish.rb

@@ -9,6 +9,8 @@ module ClaudeMemory
   class Publish
     RULES_DIR = ".claude/rules"
     GENERATED_FILE = "claude_memory.generated.md"
+    OBSERVATIONS_FILE = "claude_memory.observations.md"
+    MAX_PUBLISHED_OBSERVATIONS = 50
 
     # @param store [Store::SQLiteStore] database store for reading facts
     # @param file_system [Infrastructure::FileSystem] filesystem abstraction for I/O
@@ -45,7 +47,7 @@ module ClaudeMemory
       path = output_path(mode, rules_dir: rules_dir)
       body = generate_body(since: since)
 
-      if should_write?(path, body)
+      result = if should_write?(path, body)
         content = generate_snapshot(since: since)
         @fs.write(path, content)
         ensure_import_exists(mode, path, rules_dir: rules_dir)
@@ -53,10 +55,60 @@ module ClaudeMemory
       else
         {status: :unchanged, path: path}
       end
+
+      # The episodic observation log is published as a sibling artifact, not
+      # imported into CLAUDE.md — it reaches the session via the SessionStart
+      # context hook (Block 1). The file is a durable, diff-able snapshot.
+      publish_observations!(mode: mode, rules_dir: rules_dir)
+
+      result
+    end
+
+    # Write the episodic observation log to .claude/rules/ when there are
+    # observations to show. Mirrors publish!'s change-detection so the file is
+    # only rewritten when its body changes.
+    #
+    # @return [Hash] :status (:updated, :unchanged, or :empty) and :path
+    def publish_observations!(mode: :shared, rules_dir: nil)
+      body = observations_body
+      path = observations_path(mode, rules_dir: rules_dir)
+      return {status: :empty, path: path} if body.nil?
+
+      if should_write?(path, body)
+        @fs.write(path, observations_snapshot(body))
+        {status: :updated, path: path}
+      else
+        {status: :unchanged, path: path}
+      end
     end
 
     private
 
+    def observations_path(mode, rules_dir: nil)
+      dir = if mode == :home
+        File.join(Dir.home, ".claude", "claude_memory")
+      else
+        rules_dir || RULES_DIR
+      end
+      File.join(dir, OBSERVATIONS_FILE)
+    end
+
+    def observations_body
+      rows = @store.recent_observations(limit: MAX_PUBLISHED_OBSERVATIONS)
+      Observe::ObservationsRenderer.render(rows, title: "Project Observations")
+    end
+
+    def observations_snapshot(body)
+      <<~HEADER + body
+        <!--
+          This file is auto-generated by claude-memory.
+          Do not edit manually - changes will be overwritten.
+          Generated: #{Time.now.utc.iso8601}
+        -->
+
+      HEADER
+    end
+
     def output_path(mode, rules_dir: nil)
       case mode
       when :shared

data/lib/claude_memory/resolve/resolver.rb

@@ -27,7 +27,8 @@ module ClaudeMemory
       # @param project_path [String, nil] project path for scoped facts
       # @param scope [String] default scope for facts ("project" or "global")
       # @return [Hash] counts keyed by :entities_created, :facts_created,
-      #   :facts_superseded, :conflicts_created, :provenance_created
+      #   :facts_superseded, :conflicts_created, :provenance_created,
+      #   :observations_created, plus :fact_ids (see below)
       def apply(extraction, content_item_id: nil, occurred_at: nil, project_path: nil, scope: "project")
         occurred_at ||= Time.now.utc.iso8601
 
@@ -36,7 +37,14 @@ module ClaudeMemory
           facts_created: 0,
           facts_superseded: 0,
           conflicts_created: 0,
-          provenance_created: 0
+          provenance_created: 0,
+          observations_created: 0,
+          # Ids of the facts each input touched (insert/reinforce/conflict),
+          # positionally aligned with extraction.facts — so callers like the
+          # promotion bridge don't have to re-query for what the resolver
+          # already knows. Entries are `nil` where the fact was discarded or
+          # lost a conflict, so consumers wanting only real ids must `.compact`.
+          fact_ids: []
         }
 
         # Wrap entire extraction in a single transaction for better concurrency
@@ -52,7 +60,16 @@ module ClaudeMemory
             result[:facts_superseded] += outcome[:superseded]
             result[:conflicts_created] += outcome[:conflicts]
             result[:provenance_created] += outcome[:provenance]
+            result[:fact_ids] << outcome[:fact_id]
           end
+
+          # Episodic layer: persist observations alongside facts. Append-only,
+          # no truth maintenance — observations accumulate; the Reflector
+          # consolidates them later. Older extractions (and the empty default)
+          # carry no observations, so fact behavior is unchanged.
+          result[:observations_created] = persist_observations(
+            extraction, content_item_id, occurred_at, project_path: project_path, scope: scope
+          )
         end
 
         result
@@ -60,6 +77,25 @@ module ClaudeMemory
 
       private
 
+      # Write each observation candidate from the extraction as an episodic
+      # row. scope_hint is advisory and never overrides the resolver-determined
+      # scope (the same discipline facts follow).
+      def persist_observations(extraction, content_item_id, occurred_at, project_path:, scope:)
+        candidates = extraction.respond_to?(:observations) ? extraction.observations : []
+        candidates.each do |obs|
+          @store.insert_observation(
+            body: obs[:body],
+            kind: obs[:kind] || "event",
+            priority: obs[:priority] || Domain::Observation::INFO,
+            scope: scope,
+            project_path: (scope == "global") ? nil : project_path,
+            source_content_item_id: content_item_id,
+            observed_at: occurred_at
+          )
+        end
+        candidates.size
+      end
+
       def resolve_entities(entities)
         entity_ids = {}
         entities.uniq { |e| [e[:type], e[:name]] }.each do |e|
@@ -162,7 +198,7 @@ module ClaudeMemory
           # example text against a single-cardinality predicate that
           # already has a confirmed value. Returning zero across the
           # board keeps the resolver-result accounting consistent.
-          {created: 0, superseded: 0, conflicts: 0, provenance: 0}
+          {created: 0, superseded: 0, conflicts: 0, provenance: 0, fact_id: nil}
         else
           apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution,
             project_path: project_path, scope: scope)
@@ -173,7 +209,7 @@ module ClaudeMemory
         object_entity_id = entity_ids[fact_data[:object]]
         matching = existing_facts.find { |f| values_match?(f, fact_data[:object], object_entity_id) }
         add_provenance(matching[:id], content_item_id, fact_data)
-        {created: 0, superseded: 0, conflicts: 0, provenance: 1}
+        {created: 0, superseded: 0, conflicts: 0, provenance: 1, fact_id: matching[:id]}
       end
 
       def apply_conflict(existing_facts, fact_data, subject_id, content_item_id, occurred_at, project_path:, scope:)
@@ -188,12 +224,12 @@ module ClaudeMemory
         matching = existing_disputed.find { |f| values_match?(f, fact_data[:object], nil) }
         if matching
           add_provenance(matching[:id], content_item_id, fact_data)
-          return {created: 0, superseded: 0, conflicts: 0, provenance: 1}
+          return {created: 0, superseded: 0, conflicts: 0, provenance: 1, fact_id: matching[:id]}
         end
 
-        create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at,
+        disputed_fact_id = create_conflict(existing_facts.first[:id], fact_data, subject_id, content_item_id, occurred_at,
           project_path: project_path, scope: scope)
-        {created: 0, superseded: 0, conflicts: 1, provenance: 0}
+        {created: 0, superseded: 0, conflicts: 1, provenance: 0, fact_id: disputed_fact_id}
       end
 
       def apply_insert(fact_data, subject_id, entity_ids, content_item_id, occurred_at, existing_facts, resolution, project_path:, scope:)
@@ -208,7 +244,7 @@ module ClaudeMemory
         link_superseded_facts(fact_id, existing_facts) if superseded_count > 0
         add_provenance(fact_id, content_item_id, fact_data)
 
-        {created: 1, superseded: superseded_count, conflicts: 0, provenance: 1}
+        {created: 1, superseded: superseded_count, conflicts: 0, provenance: 1, fact_id: fact_id}
       end
 
       def insert_new_fact(fact_data, subject_id, entity_ids, occurred_at, project_path:, scope:)
@@ -278,6 +314,7 @@ module ClaudeMemory
         )
 
         add_provenance(new_fact_id, content_item_id, new_fact_data)
+        new_fact_id
       end
 
       def add_provenance(fact_id, content_item_id, fact_data)

data/lib/claude_memory/store/schema_manager.rb

@@ -5,7 +5,7 @@ module ClaudeMemory
     # Schema migration and version management for SQLiteStore.
     # Handles Sequel migrations, legacy version syncing, and initial setup.
     module SchemaManager
-      SCHEMA_VERSION = 18
+      SCHEMA_VERSION = 20
 
       private
 

data/lib/claude_memory/store/sqlite_store.rb

@@ -120,6 +120,9 @@ module ClaudeMemory
       # @return [Sequel::Dataset]
       def otel_traces = @db[:otel_traces]
 
+      # @return [Sequel::Dataset]
+      def observations = @db[:observations]
+
       # Upsert a thumbs-up/down verdict for a moment. One row per event_id
       # (unique constraint on the column) — repeat clicks overwrite. Returns
       # the persisted row.
@@ -680,6 +683,184 @@ module ClaudeMemory
           .all
       end
 
+      # --- Observations (episodic layer) ---
+
+      # Insert an episodic observation. token_count is estimated from the body
+      # when not supplied (rough ~4 chars/token) so Phase 2 budget math has a
+      # value to work with.
+      #
+      # @param body [String] dense narrative text (required)
+      # @param kind [String] one of Domain::Observation::KINDS
+      # @param priority [Integer] 1=important, 2=maybe, 3=info
+      # @param scope [String] "project" or "global"
+      # @param project_path [String, nil] project directory for project-scoped rows
+      # @param source_content_item_id [Integer, nil] provenance link to the raw chunk
+      # @param session_id [String, nil] session that produced the observation
+      # @param observed_at [String, nil] ISO 8601 event time (defaults to now UTC)
+      # @param token_count [Integer, nil] precomputed token estimate
+      # @return [Integer] inserted observation row id
+      def insert_observation(body:, kind: "event", priority: 3, scope: "project",
+        project_path: nil, source_content_item_id: nil, session_id: nil,
+        observed_at: nil, token_count: nil)
+        now = Time.now.utc.iso8601
+        with_retry("insert_observation") do
+          observations.insert(
+            body: body,
+            kind: kind,
+            priority: priority,
+            scope: scope,
+            project_path: project_path,
+            source_content_item_id: source_content_item_id,
+            token_count: token_count || (body.length / 4.0).ceil,
+            status: "active",
+            session_id: session_id,
+            observed_at: observed_at || now,
+            created_at: now
+          )
+        end
+      end
+
+      # Fetch active observations, newest first. Used by the memory.observations
+      # MCP tool and (later) the stable-prefix injection.
+      #
+      # @param scope [String, nil] filter by "project"/"global"; nil for any
+      # @param limit [Integer] maximum rows to return
+      # @param min_priority [Integer, nil] only rows with priority <= this
+      #   (1 returns only 🔴; nil returns all)
+      # @return [Array<Hash>]
+      def recent_observations(scope: nil, limit: 20, min_priority: nil)
+        ds = observations.where(status: "active")
+        ds = ds.where(scope: scope) if scope
+        ds = ds.where { priority <= min_priority } if min_priority
+        ds.order(Sequel.desc(:observed_at), Sequel.desc(:id)).limit(limit).all
+      end
+
+      # Tombstone an observation by pointing it at the consolidated row that
+      # replaced it (append-only supersession — the row is preserved, not
+      # deleted, mirroring fact_links). Used by the Reflector.
+      #
+      # @param observation_id [Integer] the superseded observation
+      # @param into_id [Integer] the consolidated observation it was merged into
+      # @return [Boolean] true if a row was updated
+      def tombstone_observation(observation_id, into_id:)
+        now = Time.now.utc.iso8601
+        updated = observations.where(id: observation_id).update(
+          status: "consolidated", consolidated_into: into_id, reflected_at: now
+        )
+        updated > 0
+      end
+
+      # Retire a stale observation (status "expired") without a consolidation
+      # target. Append-only — the row is preserved for provenance, just
+      # excluded from active recall. Used by the Reflector's TTL pass.
+      #
+      # @param observation_id [Integer]
+      # @return [Boolean] true if a row was updated
+      def expire_observation(observation_id)
+        now = Time.now.utc.iso8601
+        updated = observations.where(id: observation_id).update(status: "expired", reflected_at: now)
+        updated > 0
+      end
+
+      # Fold a duplicate's sighting count into the keeper. Called by the
+      # Reflector's dedup pass so corroboration survives consolidation — the
+      # signal the promotion gate keys off.
+      #
+      # @param observation_id [Integer] keeper observation
+      # @param by [Integer] how much to add (the loser's corroboration_count)
+      # @return [void]
+      def increment_corroboration(observation_id, by: 1)
+        observations.where(id: observation_id)
+          .update(corroboration_count: Sequel[:corroboration_count] + by)
+      end
+
+      # Mark an observation as promoted to a structured fact. Append-only: the
+      # row is preserved (provenance), it just stops being a promotion
+      # candidate.
+      #
+      # @param observation_id [Integer]
+      # @param fact_id [Integer] the fact this observation was promoted into
+      # @return [Boolean] true if a row was updated
+      def mark_observation_promoted(observation_id, fact_id:)
+        now = Time.now.utc.iso8601
+        updated = observations.where(id: observation_id)
+          .update(promoted_at: now, promoted_fact_id: fact_id, reflected_at: now)
+        updated > 0
+      end
+
+      # Semantic consolidation: merge several related observations into one
+      # synthesized observation, atomically. The new row carries the *summed*
+      # corroboration of its sources (combined sighting weight, which can tip it
+      # over the promotion threshold); each source is tombstoned into it. This
+      # is the Claude-as-reflector counterpart to the deterministic dedup — it
+      # collapses observations that say the same thing in different words, which
+      # exact-match dedup can't.
+      #
+      # @param from_ids [Array<Integer>] source observation ids (need >= 2 active in scope)
+      # @param body [String] the synthesized observation text
+      # @return [Hash, nil] {id:, merged:, corroboration_count:}, or nil when
+      #   fewer than two of the ids are active in this scope
+      def consolidate_observations(from_ids, body:, kind: "event", priority: 3, scope: "project",
+        project_path: nil, source_content_item_id: nil, observed_at: nil)
+        with_retry("consolidate_observations") do
+          @db.transaction do
+            # Read the source set *inside* the transaction so the rows we sum
+            # corroboration from are the same rows we tombstone — otherwise two
+            # reflectors (PreCompact + SessionEnd) could each read the same
+            # active sources and double-count or re-tombstone them.
+            sources = observations
+              .where(id: from_ids, status: "active", scope: scope)
+              .select(:id, :corroboration_count)
+              .all
+            next nil if sources.size < 2
+
+            now = Time.now.utc.iso8601
+            combined = sources.sum { |s| s[:corroboration_count] || 1 }
+
+            new_id = observations.insert(
+              body: body, kind: kind, priority: priority, scope: scope, project_path: project_path,
+              source_content_item_id: source_content_item_id,
+              token_count: (body.length / 4.0).ceil, corroboration_count: combined,
+              status: "active", observed_at: observed_at || now, created_at: now
+            )
+            # Re-assert `active` on the update so a source consolidated by a
+            # racing writer between read and write is not tombstoned twice.
+            observations.where(id: sources.map { |s| s[:id] }, status: "active")
+              .update(status: "consolidated", consolidated_into: new_id, reflected_at: now)
+            {id: new_id, merged: sources.size, corroboration_count: combined}
+          end
+        end
+      end
+
+      # Active, not-yet-promoted observations corroborated at least
+      # `min_corroboration` times — i.e. eligible for promotion to a fact.
+      # Highest corroboration first.
+      #
+      # @param scope [String, nil] filter by scope; nil for any
+      # @param min_corroboration [Integer] sightings required (the gate)
+      # @param limit [Integer]
+      # @return [Array<Hash>]
+      def promotion_candidates(scope: nil, min_corroboration: 2, limit: 10)
+        ds = observations.where(status: "active", promoted_at: nil)
+        ds = ds.where(scope: scope) if scope
+        ds.where { corroboration_count >= min_corroboration }
+          .order(Sequel.desc(:corroboration_count), Sequel.desc(:observed_at))
+          .limit(limit)
+          .all
+      end
+
+      # Observations that were promoted into the given fact — the reverse of
+      # promoted_fact_id, for fact→observation provenance.
+      #
+      # @param fact_id [Integer]
+      # @return [Array<Hash>]
+      def observations_for_fact(fact_id)
+        observations
+          .where(promoted_fact_id: fact_id)
+          .select(:id, :body, :kind, :corroboration_count, :observed_at)
+          .all
+      end
+
       # --- Meta ---
 
       # Set a key-value pair in the meta table (upsert).

data/lib/claude_memory/sweep/maintenance.rb

@@ -20,7 +20,8 @@ module ClaudeMemory
         mcp_tool_call_retention_days: 90,
         otel_metric_retention_days: 30,
         otel_event_retention_days: 14,
-        otel_trace_retention_days: 7
+        otel_trace_retention_days: 7,
+        observation_info_ttl_days: 30
       }.freeze
 
       attr_reader :store
@@ -394,6 +395,19 @@ module ClaudeMemory
         result
       end
 
+      # Run the deterministic observation Reflector (dedupe near-identical
+      # observations + expire stale info-level ones). Free, no LLM —
+      # provenance-preserving (tombstone, never delete).
+      # Returns: Hash {deduped:, expired:}
+      def reflect_observations
+        return {deduped: 0, expired: 0} unless @store.db.table_exists?(:observations)
+
+        result = ClaudeMemory::Observe::Reflector.new(
+          @store, info_ttl_days: @config[:observation_info_ttl_days]
+        ).reflect!
+        {deduped: result.deduped, expired: result.expired}
+      end
+
       # Run SQLite VACUUM to reclaim space.
       # Returns: true
       def vacuum

data/lib/claude_memory/sweep/sweeper.rb

@@ -11,6 +11,7 @@ module ClaudeMemory
         otel_metric_retention_days: 30,
         otel_event_retention_days: 14,
         otel_trace_retention_days: 7,
+        observation_info_ttl_days: 30,
         default_budget_seconds: 5
       }.freeze
 
@@ -51,6 +52,11 @@ module ClaudeMemory
         run_if_within_budget { @stats[:otel_traces_pruned] = maintenance.prune_old_otel_traces }
         run_if_within_budget { @stats[:vec_backfilled] = maintenance.backfill_vec_index }
         run_if_within_budget { @stats[:vec_cleaned] = maintenance.cleanup_vec_expired }
+        run_if_within_budget do
+          reflection = maintenance.reflect_observations
+          @stats[:observations_deduped] = reflection[:deduped]
+          @stats[:observations_expired] = reflection[:expired]
+        end
         run_if_within_budget { @stats[:wal_checkpointed] = maintenance.checkpoint_wal }
 
         @stats[:elapsed_seconds] = Time.now - @start_time
@@ -110,7 +116,7 @@ module ClaudeMemory
             content_retention_days: @config[:content_retention_days] / 2
           }
         else
-          @config.slice(:proposed_fact_ttl_days, :disputed_fact_ttl_days, :content_retention_days)
+          @config.slice(:proposed_fact_ttl_days, :disputed_fact_ttl_days, :content_retention_days, :observation_info_ttl_days)
         end
 
         Maintenance.new(@store, config: config)

data/lib/claude_memory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeMemory
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/lib/claude_memory.rb

@@ -38,6 +38,7 @@ require_relative "claude_memory/commands/checks/claude_md_check"
 require_relative "claude_memory/commands/checks/hooks_check"
 require_relative "claude_memory/commands/checks/reporter"
 require_relative "claude_memory/commands/checks/vec_check"
+require_relative "claude_memory/commands/checks/embeddings_check"
 require_relative "claude_memory/commands/checks/distill_check"
 require_relative "claude_memory/commands/help_command"
 require_relative "claude_memory/commands/version_command"
@@ -72,6 +73,7 @@ require_relative "claude_memory/commands/install_skill_command"
 require_relative "claude_memory/commands/completion_command"
 require_relative "claude_memory/commands/embeddings_command"
 require_relative "claude_memory/commands/reject_command"
+require_relative "claude_memory/commands/observations_command"
 require_relative "claude_memory/commands/restore_command"
 require_relative "claude_memory/commands/dedupe_conflicts_command"
 require_relative "claude_memory/commands/reclassify_references_command"
@@ -94,6 +96,7 @@ require_relative "claude_memory/dashboard/trust"
 require_relative "claude_memory/dashboard/knowledge"
 require_relative "claude_memory/dashboard/reuse"
 require_relative "claude_memory/dashboard/timeline"
+require_relative "claude_memory/dashboard/observations"
 require_relative "claude_memory/dashboard/health"
 require_relative "claude_memory/dashboard/telemetry"
 require_relative "claude_memory/dashboard/prompt_journey"
@@ -102,6 +105,7 @@ require_relative "claude_memory/dashboard/server"
 require_relative "claude_memory/commands/digest_command"
 require_relative "claude_memory/commands/show_command"
 require_relative "claude_memory/commands/otel_command"
+require_relative "claude_memory/commands/setup_vectors_command"
 require_relative "claude_memory/commands/import_auto_memory_command"
 require_relative "claude_memory/audit/finding"
 require_relative "claude_memory/audit/checks"
@@ -120,6 +124,9 @@ require_relative "claude_memory/domain/fact"
 require_relative "claude_memory/domain/entity"
 require_relative "claude_memory/domain/provenance"
 require_relative "claude_memory/domain/conflict"
+require_relative "claude_memory/domain/observation"
+require_relative "claude_memory/observe/observations_renderer"
+require_relative "claude_memory/observe/reflector"
 require_relative "claude_memory/embeddings/model_registry"
 require_relative "claude_memory/embeddings/inspector"
 require_relative "claude_memory/embeddings/generator"