claude_memory 0.9.1 → 0.11.0

data/lib/claude_memory/store/sqlite_store.rb

@@ -8,6 +8,8 @@ require "extralite"
 require "sequel/adapters/extralite"
 require_relative "retry_handler"
 require_relative "schema_manager"
+require_relative "llm_cache"
+require_relative "metrics_aggregator"
 
 module ClaudeMemory
   module Store
@@ -19,6 +21,8 @@ module ClaudeMemory
     class SQLiteStore
       include RetryHandler
       include SchemaManager
+      include LLMCache
+      include MetricsAggregator
 
       # @return [Sequel::Database] the underlying Sequel database connection
       attr_reader :db
@@ -101,6 +105,49 @@ module ClaudeMemory
       # @return [Sequel::Dataset]
       def mcp_tool_calls = @db[:mcp_tool_calls]
 
+      # @return [Sequel::Dataset]
+      def activity_events = @db[:activity_events]
+
+      # @return [Sequel::Dataset]
+      def moment_feedback = @db[:moment_feedback]
+
+      # 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.
+      #
+      # @param event_id [Integer] activity_events row id
+      # @param verdict [String] "up" or "down"
+      # @param note [String, nil] optional freeform note
+      # @param recorded_at [String, nil] ISO 8601 timestamp (defaults to now UTC)
+      # @return [Hash] row after upsert
+      def upsert_moment_feedback(event_id:, verdict:, note: nil, recorded_at: nil)
+        raise ArgumentError, "verdict must be 'up' or 'down'" unless %w[up down].include?(verdict)
+
+        ts = recorded_at || Time.now.utc.iso8601
+        with_retry do
+          @db.transaction do
+            existing = moment_feedback.where(event_id: event_id).first
+            if existing
+              moment_feedback.where(id: existing[:id]).update(
+                verdict: verdict, note: note, recorded_at: ts
+              )
+              moment_feedback.where(id: existing[:id]).first
+            else
+              id = moment_feedback.insert(
+                event_id: event_id, verdict: verdict, note: note, recorded_at: ts
+              )
+              moment_feedback.where(id: id).first
+            end
+          end
+        end
+      end
+
+      # Remove the verdict for a moment, if any.
+      # @return [Integer] number of rows deleted (0 or 1)
+      def clear_moment_feedback(event_id)
+        with_retry { moment_feedback.where(event_id: event_id).delete }
+      end
+
       # Record a single MCP tool invocation for telemetry.
       # Inserts synchronously; callers wrap in with_retry at the call site
       # if needed.
@@ -497,149 +544,6 @@ module ClaudeMemory
           .all
       end
 
-      # Count content items that have not yet been distilled.
-      # @param min_length [Integer] minimum byte_len threshold
-      # @return [Integer]
-      def count_undistilled(min_length: 200)
-        content_items
-          .left_join(:ingestion_metrics, content_item_id: :id)
-          .where(Sequel[:ingestion_metrics][:id] => nil)
-          .where { byte_len >= min_length }
-          .count
-      end
-
-      # Record token usage and extraction counts for a distillation run.
-      # @param content_item_id [Integer] content item that was distilled
-      # @param input_tokens [Integer] LLM input tokens consumed
-      # @param output_tokens [Integer] LLM output tokens consumed
-      # @param facts_extracted [Integer] number of facts extracted
-      # @return [Integer] inserted row id
-      def record_ingestion_metrics(content_item_id:, input_tokens:, output_tokens:, facts_extracted:)
-        ingestion_metrics.insert(
-          content_item_id: content_item_id,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          facts_extracted: facts_extracted,
-          created_at: Time.now.utc.iso8601
-        )
-      end
-
-      # Compute aggregate ingestion metrics across all distillation runs.
-      # @return [Hash, nil] totals and efficiency ratio, or nil if no data
-      def aggregate_ingestion_metrics
-        # standard:disable Performance/Detect (Sequel DSL requires .select{}.first)
-        result = ingestion_metrics
-          .select {
-            [
-              sum(:input_tokens).as(:total_input),
-              sum(:output_tokens).as(:total_output),
-              sum(:facts_extracted).as(:total_facts),
-              count(:id).as(:total_ops)
-            ]
-          }
-          .first
-        # standard:enable Performance/Detect
-
-        return nil if result.nil? || result[:total_ops].to_i.zero?
-
-        total_input = result[:total_input].to_i
-        total_output = result[:total_output].to_i
-        total_facts = result[:total_facts].to_i
-        total_ops = result[:total_ops].to_i
-
-        efficiency = total_input.zero? ? 0.0 : (total_facts.to_f / total_input * 1000).round(2)
-
-        {
-          total_input_tokens: total_input,
-          total_output_tokens: total_output,
-          total_facts_extracted: total_facts,
-          total_operations: total_ops,
-          avg_facts_per_1k_input_tokens: efficiency
-        }
-      end
-
-      # Mark all undistilled content items as distilled with zero token counts.
-      # Used for backfilling legacy content that predates the metrics table.
-      # @return [Integer] number of items backfilled
-      def backfill_distillation_metrics!
-        undistilled_ids = content_items
-          .left_join(:ingestion_metrics, content_item_id: :id)
-          .where(Sequel[:ingestion_metrics][:id] => nil)
-          .select_map(Sequel[:content_items][:id])
-
-        return 0 if undistilled_ids.empty?
-
-        now = Time.now.utc.iso8601
-        undistilled_ids.each do |cid|
-          ingestion_metrics.insert(
-            content_item_id: cid,
-            input_tokens: 0,
-            output_tokens: 0,
-            facts_extracted: 0,
-            created_at: now
-          )
-        end
-
-        undistilled_ids.size
-      end
-
-      # --- LLM cache ---
-
-      # Look up a cached LLM result by its cache key.
-      # @param cache_key [String] SHA-256 hex cache key
-      # @return [Hash, nil]
-      def llm_cache_lookup(cache_key)
-        llm_cache.where(cache_key: cache_key).first
-      end
-
-      # Store or update a cached LLM result. Uses upsert on the cache_key.
-      # @param operation [String] operation name (e.g. "distill", "embed")
-      # @param model [String] model identifier
-      # @param input_hash [String] SHA-256 hex digest of the input
-      # @param result_json [String] JSON-serialized result
-      # @param input_tokens [Integer, nil] input tokens consumed
-      # @param output_tokens [Integer, nil] output tokens consumed
-      # @return [void]
-      def llm_cache_store(operation:, model:, input_hash:, result_json:, input_tokens: nil, output_tokens: nil)
-        cache_key = Digest::SHA256.hexdigest("#{operation}:#{model}:#{input_hash}")
-
-        llm_cache
-          .insert_conflict(target: :cache_key, update: {
-            result_json: result_json,
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            created_at: Time.now.utc.iso8601
-          })
-          .insert(
-            cache_key: cache_key,
-            operation: operation,
-            model: model,
-            input_hash: input_hash,
-            result_json: result_json,
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            created_at: Time.now.utc.iso8601
-          )
-      end
-
-      # Compute the cache key for an LLM operation.
-      # @param operation [String] operation name
-      # @param model [String] model identifier
-      # @param input [String] raw input text
-      # @return [String] SHA-256 hex cache key
-      def llm_cache_key(operation, model, input)
-        input_hash = Digest::SHA256.hexdigest(input)
-        Digest::SHA256.hexdigest("#{operation}:#{model}:#{input_hash}")
-      end
-
-      # Delete LLM cache entries older than the given age.
-      # @param max_age_seconds [Integer] maximum age in seconds (default: 7 days)
-      # @return [Integer] number of rows deleted
-      def llm_cache_prune(max_age_seconds: 604_800)
-        cutoff = (Time.now - max_age_seconds).utc.iso8601
-        llm_cache.where { created_at < cutoff }.delete
-      end
-
       # --- Meta ---
 
       # Set a key-value pair in the meta table (upsert).

data/lib/claude_memory/store/store_manager.rb

@@ -118,6 +118,35 @@ module ClaudeMemory
         end
       end
 
+      # Return the store for an explicit scope only if its database file
+      # already exists on disk. Never creates a new DB. Useful for
+      # read-only surfaces that want to avoid accidental initialization.
+      # @param scope [String] "global" or "project"
+      # @return [SQLiteStore, nil]
+      def store_if_exists(scope)
+        case scope
+        when "project"
+          return nil unless project_exists?
+          ensure_project!
+        when "global"
+          return nil unless global_exists?
+          ensure_global!
+        end
+      end
+
+      # Return whichever store is available, preferring the requested scope.
+      # Falls back to the other scope if the preferred DB doesn't exist on
+      # disk yet. Returns nil only when both DBs are missing. Intended for
+      # "best-effort" surfaces like activity logging and default dashboard
+      # reads where the caller just needs some store to talk to.
+      # @param prefer [Symbol] :project (default) or :global
+      # @return [SQLiteStore, nil]
+      def default_store(prefer: :project)
+        primary = (prefer == :global) ? "global" : "project"
+        fallback = (prefer == :global) ? "project" : "global"
+        store_if_exists(primary) || store_if_exists(fallback)
+      end
+
       # Copy a project-scoped fact (with its entities and provenance) into the
       # global store, making it available across all projects. Runs the global
       # writes in a single transaction for atomicity.

data/lib/claude_memory/sweep/maintenance.rb

@@ -47,6 +47,74 @@ module ClaudeMemory
           .update(status: "expired")
       end
 
+      # Collapse duplicate multi-value facts. Before the resolver-level
+      # dedup fix (2026-04-17), multi-value predicates like uses_language
+      # and uses_framework accumulated identical rows every ingest cycle.
+      # For each (subject_entity_id, predicate, object_literal, scope) group
+      # with more than one active fact, keep the oldest row, copy the
+      # duplicates' provenance onto the keeper (so we retain source
+      # signal), and mark the duplicates superseded. Returns the count of
+      # fact rows merged into their keeper.
+      def dedupe_multi_value_facts
+        merged = 0
+        @store.db.transaction do
+          # Pull every active fact with a literal object and group in Ruby.
+          # Facts tables stay small (< 10k typical); Sequel's HAVING COUNT(*)
+          # path hits adapter quoting bugs on some Extralite versions.
+          active = @store.facts
+            .where(status: "active")
+            .exclude(subject_entity_id: nil)
+            .exclude(object_literal: nil)
+            .order(:id)
+            .all
+
+          groups = active.group_by { |f|
+            [f[:subject_entity_id], f[:predicate], f[:object_literal]&.downcase, f[:scope]]
+          }
+
+          groups.each_value do |rows|
+            next if rows.size < 2
+
+            keeper = rows.first
+            rows[1..].each do |loser|
+              @store.provenance.where(fact_id: loser[:id]).update(fact_id: keeper[:id])
+              @store.facts.where(id: loser[:id]).update(
+                status: "superseded",
+                valid_to: Time.now.utc.iso8601
+              )
+              @store.insert_fact_link(from_fact_id: keeper[:id], to_fact_id: loser[:id], link_type: "supersedes")
+              merged += 1
+            end
+          end
+        end
+        merged
+      end
+
+      # Fix scope leakage: facts whose `scope` column disagrees with the
+      # store they live in. Pre-2026-04-20, the resolver treated
+      # scope_hint from the distiller as a scope override — so when the
+      # NullDistiller detected global-scope language ("always", "my
+      # preference"), it stamped scope: "global" on facts that still
+      # ended up written to the project DB. The result was invisible
+      # orphaned rows: not in the global DB so global recall never saw
+      # them, but labeled global inside the project DB.
+      #
+      # This pass detects those rows by comparing `scope` to the
+      # expected value derived from which DB this Maintenance instance
+      # is running against, and rewrites scope + project_path to match.
+      # Does not move facts between DBs — users can `claude-memory
+      # promote <id>` to do a proper cross-store copy.
+      # Returns: Integer count of facts whose scope was corrected.
+      def fix_scope_leakage
+        expected = expected_scope_for_store
+        return 0 unless expected
+
+        project_path_for_scope = (expected == "global") ? nil : detect_project_path
+        @store.facts
+          .exclude(scope: expected)
+          .update(scope: expected, project_path: project_path_for_scope)
+      end
+
       # Delete provenance records referencing non-existent facts.
       # Returns: Integer count of deleted provenance rows
       def prune_orphaned_provenance
@@ -188,6 +256,114 @@ module ClaudeMemory
         true
       end
 
+      # Deduplicate open conflicts that describe the same contradiction.
+      # Before the Resolver#apply_conflict dedupe fix (2026-04-24), each
+      # re-extraction of the losing value in a single-value slot produced
+      # a new disputed fact + conflict row — production DBs accumulated 11
+      # open conflicts for "sqlite vs postgresql" referencing 11 different
+      # disputed facts. This pass keeps the earliest conflict per logical
+      # pair and marks the rest resolved, reinforcing the keeper's
+      # provenance chain with the duplicates' provenance.
+      #
+      # Pair key: (subject_entity_id, predicate, normalized(object_a), normalized(object_b))
+      # with object order sorted so A-vs-B == B-vs-A.
+      #
+      # @param dry_run [Boolean] when true, decide but don't write
+      # @return [Hash] {inspected:, resolved:, decisions: [{conflict_id:, action:, keeper_id:}]}
+      def dedupe_open_conflicts(dry_run: false)
+        result = {inspected: 0, resolved: 0, decisions: []}
+
+        open_rows = @store.conflicts
+          .where(status: "open")
+          .order(:id)
+          .all
+        return result if open_rows.empty?
+
+        fact_ids = open_rows.flat_map { |r| [r[:fact_a_id], r[:fact_b_id]] }.uniq
+        facts = @store.facts
+          .where(id: fact_ids)
+          .select(:id, :subject_entity_id, :predicate, :object_literal, :status)
+          .all
+          .to_h { |f| [f[:id], f] }
+
+        @store.db.transaction do
+          groups = open_rows.group_by { |row| pair_key(row, facts) }.reject { |key, _| key.nil? }
+          groups.each_value do |rows_in_group|
+            result[:inspected] += rows_in_group.size
+            next if rows_in_group.size < 2
+
+            keeper = rows_in_group.first
+            duplicates = rows_in_group[1..]
+            duplicates.each do |dup|
+              result[:decisions] << {
+                conflict_id: dup[:id],
+                action: :resolve_duplicate,
+                keeper_id: keeper[:id],
+                duplicate_fact_id: dup[:fact_b_id]
+              }
+              # Counted whether or not we actually write, so dry-run output
+              # matches real-run output and callers can compare plans.
+              result[:resolved] += 1
+              next if dry_run
+
+              # Resolve the duplicate conflict. Also reject its disputed
+              # side (fact_b_id is always the newer inserted-as-disputed
+              # fact per Resolver convention), and shift its provenance
+              # onto the keeper's fact_b so the evidence isn't lost.
+              keeper_fact_b_id = keeper[:fact_b_id]
+              if dup[:fact_b_id] != keeper_fact_b_id
+                @store.provenance.where(fact_id: dup[:fact_b_id]).update(fact_id: keeper_fact_b_id)
+                @store.facts.where(id: dup[:fact_b_id]).update(
+                  status: "rejected",
+                  valid_to: Time.now.utc.iso8601
+                )
+              end
+              @store.conflicts.where(id: dup[:id]).update(
+                status: "resolved",
+                notes: "Deduplicated into conflict ##{keeper[:id]}"
+              )
+            end
+          end
+        end
+
+        result
+      end
+
+      # Reclassify active facts currently labeled `convention` whose object
+      # text matches the ReferenceMaterialDetector heuristics. Fixes the
+      # historical data tail from before the detector was wired into
+      # `store_extraction` on 2026-04-24. Current writes can't create this
+      # pattern — this pass only cleans up what already exists.
+      #
+      # @param dry_run [Boolean] when true, decide but don't write
+      # @return [Hash] {inspected:, reclassified:, decisions: [{fact_id:, object:}]}
+      def reclassify_references(dry_run: false)
+        detector = ClaudeMemory::Distill::ReferenceMaterialDetector.new
+        result = {inspected: 0, reclassified: 0, decisions: []}
+
+        candidates = @store.facts
+          .where(status: "active", predicate: "convention")
+          .select(:id, :object_literal)
+          .all
+
+        @store.db.transaction do
+          candidates.each do |row|
+            result[:inspected] += 1
+            fact = {predicate: "convention", object: row[:object_literal]}
+            next unless detector.reference_material?(fact)
+
+            result[:decisions] << {fact_id: row[:id], object: row[:object_literal]}
+            result[:reclassified] += 1
+
+            unless dry_run
+              @store.facts.where(id: row[:id]).update(predicate: "reference")
+            end
+          end
+        end
+
+        result
+      end
+
       # Run SQLite VACUUM to reclaim space.
       # Returns: true
       def vacuum
@@ -197,6 +373,20 @@ module ClaudeMemory
 
       private
 
+      # Canonical key for grouping open conflicts. Two conflicts are the
+      # "same" when they involve the same subject, predicate, and set of
+      # objects (A-vs-B == B-vs-A). Missing-fact conflicts (either side
+      # deleted) get a nil key and are skipped by the caller.
+      def pair_key(conflict_row, facts_by_id)
+        a = facts_by_id[conflict_row[:fact_a_id]]
+        b = facts_by_id[conflict_row[:fact_b_id]]
+        return nil unless a && b
+        return nil unless a[:subject_entity_id] == b[:subject_entity_id]
+        return nil unless a[:predicate] == b[:predicate]
+        objects = [a[:object_literal].to_s.downcase.strip, b[:object_literal].to_s.downcase.strip].sort
+        [a[:subject_entity_id], a[:predicate], objects]
+      end
+
       def restore_tokenize(text)
         return Set.new if text.nil?
         text.downcase
@@ -230,6 +420,32 @@ module ClaudeMemory
         (Time.now - days * 86400).utc.iso8601
       end
 
+      # Infer the scope each store is supposed to carry by comparing its
+      # DB path to the canonical Configuration paths. Returns "global" for
+      # the user-wide DB, "project" for the per-project DB, or nil when
+      # the path doesn't match either (custom test paths, etc. — in which
+      # case fix_scope_leakage is a no-op).
+      def expected_scope_for_store
+        path = @store.db.opts[:database].to_s
+        return nil if path.empty?
+        config = ClaudeMemory::Configuration.new
+        return "global" if File.expand_path(path) == File.expand_path(config.global_db_path)
+
+        # Project DB lives at <project>/.claude/memory.sqlite3 — we can
+        # always check whether the DB path sits under a .claude directory
+        # to classify it as project-scoped regardless of which project.
+        File.dirname(File.expand_path(path)).end_with?("/.claude") ? "project" : nil
+      end
+
+      def detect_project_path
+        path = @store.db.opts[:database].to_s
+        return nil if path.empty?
+        # The canonical project DB lives at <project>/.claude/memory.sqlite3
+        # so the project path is two levels up.
+        project = File.dirname(File.expand_path(path), 2)
+        Dir.exist?(project) ? project : nil
+      end
+
       def with_vec_index
         vec_index = @store.vector_index
         return unless vec_index.available?

data/lib/claude_memory/sweep/recall_timestamp_refresher.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ClaudeMemory
+  module Sweep
+    # Path B for #35 access-based staleness — sweep-derived rather than
+    # per-recall written. Scans activity_events from both stores, projects
+    # the most recent recall/context-injection touch per (scope, fact_id),
+    # and bulk-updates facts.last_recalled_at across both DBs.
+    #
+    # Cross-DB by design: project DBs record activity_events for both
+    # project and global facts (a recall fired from a project context that
+    # returns global facts is logged in the project DB), so a per-store
+    # refresh would silently miss global facts entirely.
+    #
+    # Lookback bounds keep the scan O(window), not O(history).
+    class RecallTimestampRefresher
+      DEFAULT_LOOKBACK_DAYS = 90
+      RECALL_EVENT_TYPES = %w[recall hook_context].freeze
+
+      def initialize(manager, lookback_days: DEFAULT_LOOKBACK_DAYS)
+        @manager = manager
+        @lookback_days = lookback_days
+      end
+
+      # @return [Hash] {project: Int, global: Int} — count of facts updated per scope.
+      def refresh!
+        cutoff = (Time.now.utc - @lookback_days * 86_400).iso8601
+        latest = collect_latest_per_fact(cutoff)
+        apply_to_stores(latest)
+      end
+
+      private
+
+      # Scans every activity_events table available to the manager and
+      # returns {[scope, fact_id] => latest_occurred_at}.
+      def collect_latest_per_fact(cutoff)
+        latest = {}
+        %w[project global].each do |source|
+          store = @manager.store_if_exists(source)
+          next unless store
+          rows = store.activity_events
+            .where(event_type: RECALL_EVENT_TYPES)
+            .where { occurred_at >= cutoff }
+            .select(:occurred_at, :detail_json)
+            .all
+          rows.each do |row|
+            details = parse_details(row[:detail_json])
+            scoped = Dashboard::ScopedFactResolver.scoped_ids_from_details(details)
+            scoped.each do |scope, ids|
+              ids.each do |fact_id|
+                key = [scope.to_s, fact_id]
+                existing = latest[key]
+                latest[key] = row[:occurred_at] if existing.nil? || row[:occurred_at] > existing
+              end
+            end
+          end
+        end
+        latest
+      end
+
+      def parse_details(detail_json)
+        return {} if detail_json.nil? || detail_json.empty?
+        JSON.parse(detail_json, symbolize_names: true)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def apply_to_stores(latest)
+        counts = {project: 0, global: 0}
+        latest.group_by { |(scope, _id), _ts| scope }.each do |scope, entries|
+          store = @manager.store_if_exists(scope)
+          next unless store
+          entries.each do |((_scope, fact_id), ts)|
+            counts[scope.to_sym] += store.facts.where(id: fact_id).update(last_recalled_at: ts)
+          end
+        end
+        counts
+      end
+    end
+  end
+end

data/lib/claude_memory/sweep/sweeper.rb

@@ -38,6 +38,8 @@ module ClaudeMemory
 
         run_if_within_budget { @stats[:proposed_facts_expired] = maintenance.expire_proposed_facts }
         run_if_within_budget { @stats[:disputed_facts_expired] = maintenance.expire_disputed_facts }
+        run_if_within_budget { @stats[:multi_value_facts_merged] = maintenance.dedupe_multi_value_facts }
+        run_if_within_budget { @stats[:scope_leakage_fixed] = maintenance.fix_scope_leakage }
         run_if_within_budget { @stats[:orphaned_provenance_deleted] = maintenance.prune_orphaned_provenance }
         run_if_within_budget { @stats[:old_content_pruned] = maintenance.prune_old_content }
         run_if_within_budget { @stats[:mcp_tool_calls_pruned] = maintenance.prune_old_mcp_tool_calls }

data/lib/claude_memory/templates/hooks.example.json

@@ -68,6 +68,11 @@
             "command": "claude-memory hook sweep",
             "timeout": 30,
             "statusMessage": "Sweeping memory..."
+          },
+          {
+            "type": "command",
+            "command": "claude-memory hook nudge",
+            "timeout": 5
           }
         ]
       }

data/lib/claude_memory/version.rb

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

data/lib/claude_memory.rb

@@ -73,12 +73,32 @@ 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/restore_command"
+require_relative "claude_memory/commands/dedupe_conflicts_command"
+require_relative "claude_memory/commands/reclassify_references_command"
+require_relative "claude_memory/commands/census_command"
+require_relative "claude_memory/commands/dashboard_command"
+require_relative "claude_memory/dashboard/fact_presenter"
+require_relative "claude_memory/dashboard/scoped_fact_resolver"
+require_relative "claude_memory/dashboard/conflicts"
+require_relative "claude_memory/dashboard/efficacy"
+require_relative "claude_memory/dashboard/moments"
+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/health"
+require_relative "claude_memory/dashboard/api"
+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/registry"
 require_relative "claude_memory/cli"
 require_relative "claude_memory/configuration"
 require_relative "claude_memory/distill/distiller"
 require_relative "claude_memory/distill/extraction"
 require_relative "claude_memory/distill/null_distiller"
+require_relative "claude_memory/distill/reference_material_detector"
+require_relative "claude_memory/distill/bare_conclusion_detector"
 require_relative "claude_memory/domain/fact"
 require_relative "claude_memory/domain/entity"
 require_relative "claude_memory/domain/provenance"
@@ -91,6 +111,7 @@ require_relative "claude_memory/embeddings/api_adapter"
 require_relative "claude_memory/embeddings/dimension_check"
 require_relative "claude_memory/embeddings/resolver"
 require_relative "claude_memory/embeddings/similarity"
+require_relative "claude_memory/hook/auto_memory_mirror"
 require_relative "claude_memory/hook/context_injector"
 require_relative "claude_memory/hook/distillation_runner"
 require_relative "claude_memory/hook/exit_codes"
@@ -109,6 +130,7 @@ require_relative "claude_memory/ingest/tool_extractor"
 require_relative "claude_memory/ingest/tool_filter"
 require_relative "claude_memory/ingest/ingester"
 require_relative "claude_memory/ingest/transcript_reader"
+require_relative "claude_memory/activity_log"
 require_relative "claude_memory/logging/logger"
 require_relative "claude_memory/infrastructure/file_system"
 require_relative "claude_memory/infrastructure/in_memory_file_system"
@@ -126,6 +148,7 @@ require_relative "claude_memory/recall/expansion_detector"
 require_relative "claude_memory/recall/query_core"
 require_relative "claude_memory/recall/legacy_engine"
 require_relative "claude_memory/recall/dual_engine"
+require_relative "claude_memory/recall/stale_detector"
 require_relative "claude_memory/recall"
 require_relative "claude_memory/shortcuts"
 require_relative "claude_memory/resolve/predicate_policy"
@@ -134,6 +157,7 @@ require_relative "claude_memory/store/sqlite_store"
 require_relative "claude_memory/store/store_manager"
 require_relative "claude_memory/sweep/maintenance"
 require_relative "claude_memory/sweep/sweeper"
+require_relative "claude_memory/sweep/recall_timestamp_refresher"
 require_relative "claude_memory/version"
 
 module ClaudeMemory