claude_memory 0.7.1 → 0.9.0

data/lib/claude_memory/commands/checks/vec_check.rb

@@ -52,7 +52,8 @@ module ClaudeMemory
               stats = store.vector_index.coverage_stats
               totals[:with_embedding] += stats[:with_embedding]
               totals[:vec_indexed] += stats[:vec_indexed]
-            rescue => _e
+            rescue => e
+              ClaudeMemory.logger.debug("VecCheck failed for #{db_path}: #{e.message}")
               next
             ensure
               store&.close

data/lib/claude_memory/commands/completion_command.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    # Generates shell completion scripts for bash and zsh.
+    # Outputs completion script to stdout for eval or redirection.
+    class CompletionCommand < BaseCommand
+      def call(args)
+        opts = parse_options(args, {shell: detect_shell}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory completion [options]"
+            parser.on("--shell SHELL", %w[bash zsh], "Shell type: bash or zsh (auto-detected)") { |v| o[:shell] = v }
+          end
+        end
+        return 1 if opts.nil?
+
+        case opts[:shell]
+        when "zsh"
+          stdout.puts zsh_completion
+        when "bash"
+          stdout.puts bash_completion
+        else
+          return failure("Unknown shell: #{opts[:shell]}. Use --shell bash or --shell zsh")
+        end
+        0
+      end
+
+      private
+
+      def detect_shell
+        shell = ENV.fetch("SHELL", "/bin/bash")
+        File.basename(shell)
+      end
+
+      def command_names
+        Registry.all_commands.sort
+      end
+
+      def zsh_completion
+        commands_with_desc = Registry.descriptions.sort.map { |name, desc|
+          "    '#{name}:#{desc}'"
+        }.join("\n")
+
+        <<~ZSH
+          #compdef claude-memory
+
+          _claude_memory() {
+            local -a commands
+            commands=(
+          #{commands_with_desc}
+            )
+
+            _arguments -C \\
+              '1:command:->command' \\
+              '*::arg:->args'
+
+            case $state in
+              command)
+                _describe 'command' commands
+                ;;
+              args)
+                case $words[1] in
+                  recall|search|explain)
+                    _arguments '*:query:'
+                    ;;
+                  promote)
+                    _arguments '*:fact_id:'
+                    ;;
+                  hook)
+                    local -a subcommands
+                    subcommands=('ingest:Ingest transcript' 'sweep:Run maintenance' 'publish:Publish snapshot' 'context:Inject context')
+                    _describe 'subcommand' subcommands
+                    ;;
+                  compact|export|changes|stats|sweep|conflicts)
+                    _arguments '--scope[Scope]:scope:(all global project)'
+                    ;;
+                  index)
+                    _arguments '--vec[Build vector index]' '--rebuild[Rebuild from scratch]'
+                    ;;
+                  completion)
+                    _arguments '--shell[Shell type]:shell:(bash zsh)'
+                    ;;
+                  install-skill)
+                    local -a skills
+                    skills=(#{skill_names.map { |s| "'#{s}'" }.join(" ")})
+                    _arguments '--list[List available skills]' '--force[Overwrite existing]' '1:skill:($skills)'
+                    ;;
+                esac
+                ;;
+            esac
+          }
+
+          _claude_memory "$@"
+        ZSH
+      end
+
+      def bash_completion
+        <<~BASH
+          # bash completion for claude-memory
+
+          _claude_memory() {
+            local cur prev commands
+            COMPREPLY=()
+            cur="${COMP_WORDS[COMP_CWORD]}"
+            prev="${COMP_WORDS[COMP_CWORD-1]}"
+            commands="#{command_names.join(" ")}"
+
+            if [[ ${COMP_CWORD} -eq 1 ]]; then
+              COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
+              return 0
+            fi
+
+            case "${COMP_WORDS[1]}" in
+              hook)
+                COMPREPLY=( $(compgen -W "ingest sweep publish context" -- "${cur}") )
+                ;;
+              compact|export|changes|stats|sweep|conflicts)
+                if [[ "${prev}" == "--scope" ]]; then
+                  COMPREPLY=( $(compgen -W "all global project" -- "${cur}") )
+                else
+                  COMPREPLY=( $(compgen -W "--scope" -- "${cur}") )
+                fi
+                ;;
+              install-skill)
+                if [[ "${prev}" == "install-skill" ]]; then
+                  COMPREPLY=( $(compgen -W "#{skill_names.join(" ")} --list --force" -- "${cur}") )
+                fi
+                ;;
+              completion)
+                if [[ "${prev}" == "--shell" ]]; then
+                  COMPREPLY=( $(compgen -W "bash zsh" -- "${cur}") )
+                else
+                  COMPREPLY=( $(compgen -W "--shell" -- "${cur}") )
+                fi
+                ;;
+            esac
+            return 0
+          }
+
+          complete -F _claude_memory claude-memory
+        BASH
+      end
+
+      def skill_names
+        InstallSkillCommand::AVAILABLE_SKILLS.keys
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/doctor_command.rb

@@ -20,6 +20,8 @@ module ClaudeMemory
         checks = [
           Checks::DatabaseCheck.new(manager.global_db_path, "global"),
           Checks::DatabaseCheck.new(manager.project_db_path, "project"),
+          Checks::DistillCheck.new(manager.global_db_path, "global"),
+          Checks::DistillCheck.new(manager.project_db_path, "project"),
           Checks::VecCheck.new,
           Checks::SnapshotCheck.new,
           Checks::ClaudeMdCheck.new,

data/lib/claude_memory/commands/embeddings_command.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    # Shows embedding configuration, lists available models, and validates setup.
+    #
+    # Subcommands:
+    #   claude-memory embeddings          # Show current config
+    #   claude-memory embeddings list     # List available models
+    #   claude-memory embeddings check    # Validate current setup
+    #
+    class EmbeddingsCommand < BaseCommand
+      def call(args)
+        opts = parse_options(args, {}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory embeddings [list|check]"
+          end
+        end
+        return 1 if opts.nil?
+
+        subcommand = args.first
+
+        case subcommand
+        when "list" then list_models
+        when "check" then check_setup
+        when nil then show_config
+        else
+          failure("Unknown subcommand: #{subcommand}. Use: list, check")
+        end
+      end
+
+      private
+
+      def inspector
+        @inspector ||= Embeddings::Inspector.new
+      end
+
+      def show_config
+        provider = ENV["CLAUDE_MEMORY_EMBEDDING_PROVIDER"] || "tfidf"
+        model = ENV["CLAUDE_MEMORY_EMBEDDING_MODEL"]
+        api_url = ENV["CLAUDE_MEMORY_EMBEDDING_API_URL"]
+
+        stdout.puts "Embedding Configuration"
+        stdout.puts "======================"
+        stdout.puts "Provider:  #{provider}"
+        stdout.puts "Model:     #{model || "(default)"}"
+
+        if model
+          info = Embeddings::ModelRegistry.find(model)
+          if info
+            stdout.puts "Dimensions: #{info.dimensions}"
+            stdout.puts "Description: #{info.description}"
+          else
+            stdout.puts "Dimensions: (unknown - will be discovered at runtime)"
+          end
+        else
+          info = Embeddings::ModelRegistry.default_for_provider(provider)
+          if info
+            stdout.puts "Default model: #{info.name}"
+            stdout.puts "Dimensions: #{info.dimensions}"
+          end
+        end
+
+        stdout.puts "API URL:   #{api_url}" if api_url && provider == "api"
+
+        inspector.database_states.each do |state|
+          stdout.puts ""
+          stdout.puts "#{state.label.capitalize} DB: provider=#{state.provider || "unknown"}, dimensions=#{state.dimensions || "unknown"}"
+        end
+
+        stdout.puts ""
+        stdout.puts "ENV variables:"
+        stdout.puts "  CLAUDE_MEMORY_EMBEDDING_PROVIDER  Provider (tfidf, fastembed, api)"
+        stdout.puts "  CLAUDE_MEMORY_EMBEDDING_MODEL     Model name"
+        stdout.puts "  CLAUDE_MEMORY_EMBEDDING_API_KEY   API key (for api provider)"
+        stdout.puts "  CLAUDE_MEMORY_EMBEDDING_API_URL   API endpoint (for api provider)"
+        0
+      end
+
+      def list_models
+        Embeddings::ModelRegistry.providers.each do |provider|
+          stdout.puts ""
+          stdout.puts "#{provider_label(provider)}:"
+          stdout.puts "-" * 40
+
+          Embeddings::ModelRegistry.models_for_provider(provider).each do |model|
+            size = model.size_mb ? "#{model.size_mb}MB" : "cloud"
+            tokens = model.max_tokens ? "#{model.max_tokens} tokens" : ""
+            stdout.puts "  #{model.name}"
+            stdout.puts "    #{model.dimensions}-dim | #{size} | #{tokens}"
+            stdout.puts "    #{model.description}"
+          end
+        end
+
+        stdout.puts ""
+        stdout.puts "Custom models: Set CLAUDE_MEMORY_EMBEDDING_MODEL to any model"
+        stdout.puts "supported by your provider. Dimensions are auto-detected."
+        0
+      end
+
+      def check_setup
+        provider_name = ENV["CLAUDE_MEMORY_EMBEDDING_PROVIDER"] || "tfidf"
+        model_name = ENV["CLAUDE_MEMORY_EMBEDDING_MODEL"]
+
+        stdout.puts "Checking embedding setup..."
+        stdout.puts ""
+
+        ok = true
+        ok &= check_provider(provider_name)
+        ok &= check_model(provider_name, model_name) if model_name
+        ok &= render_dimension_checks(provider_name, model_name)
+
+        stdout.puts ""
+        stdout.puts ok ? "All checks passed." : "Some checks failed. See above."
+        ok ? 0 : 1
+      end
+
+      def check_provider(name)
+        case name
+        when "fastembed"
+          check_fastembed
+        when "api"
+          check_api_config
+        when "tfidf"
+          stdout.puts "  [OK] tfidf provider (built-in, always available)"
+          true
+        else
+          stdout.puts "  [FAIL] Unknown provider: #{name}"
+          false
+        end
+      end
+
+      def check_model(provider_name, model_name)
+        info = Embeddings::ModelRegistry.find(model_name)
+        if info
+          if info.provider != provider_name
+            stdout.puts "  [WARN] Model '#{model_name}' is for '#{info.provider}' provider, but '#{provider_name}' is selected"
+            stdout.puts "         Set CLAUDE_MEMORY_EMBEDDING_PROVIDER=#{info.provider}"
+          else
+            stdout.puts "  [OK] Model '#{model_name}' (#{info.dimensions}-dim)"
+          end
+        else
+          stdout.puts "  [INFO] Model '#{model_name}' not in registry (dimensions will be auto-detected)"
+        end
+        true
+      end
+
+      def render_dimension_checks(provider_name, model_name)
+        ok = true
+
+        inspector.dimension_checks(provider_name, model_name).each do |check|
+          case check.status
+          when :mismatch
+            stdout.puts "  [WARN] #{check.label}: Dimension mismatch (stored: #{check.stored_dims}, current: #{check.current_dims})"
+            stdout.puts "         Re-index with: claude-memory index --force --scope #{check.label}"
+            ok = false
+          when :match
+            stdout.puts "  [OK] #{check.label}: #{check.stored_dims}-dim (provider: #{check.stored_provider || "unknown"})"
+          when :fresh
+            stdout.puts "  [INFO] #{check.label}: No embeddings indexed yet"
+          end
+        end
+
+        ok
+      end
+
+      def check_fastembed
+        require "fastembed"
+        stdout.puts "  [OK] fastembed gem available"
+        true
+      rescue LoadError
+        stdout.puts "  [FAIL] fastembed gem not installed"
+        stdout.puts "         Add `gem 'fastembed'` to your Gemfile"
+        false
+      end
+
+      def check_api_config
+        key = ENV["CLAUDE_MEMORY_EMBEDDING_API_KEY"] || ENV["OPENAI_API_KEY"]
+        if key
+          stdout.puts "  [OK] API key configured"
+          true
+        else
+          stdout.puts "  [FAIL] No API key found"
+          stdout.puts "         Set CLAUDE_MEMORY_EMBEDDING_API_KEY or OPENAI_API_KEY"
+          false
+        end
+      end
+
+      def provider_label(provider)
+        case provider
+        when "fastembed" then "fastembed (local ONNX, no API key)"
+        when "api" then "api (OpenAI-compatible endpoints, requires API key)"
+        when "tfidf" then "tfidf (built-in, no dependencies)"
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/help_command.rb

@@ -19,18 +19,29 @@ module ClaudeMemory
             explain    Explain a fact with receipts
             export     Export facts to JSON for backup
             help       Show this help message
-            hook       Run hook entrypoints (ingest|sweep|publish)
+            hook       Run hook entrypoints (ingest|sweep|publish|context)
             init       Initialize ClaudeMemory in a project
             ingest     Ingest transcript delta
             promote    Promote a project fact to global memory
             publish    Publish snapshot to Claude Code memory
             recall     Recall facts matching a query
+            recover    Recover stuck operations
+            reject     Mark a fact as rejected (e.g. hallucination)
+            restore    Restore superseded facts from reclassified predicates
             search     Search indexed content
             serve-mcp  Start MCP server
+            stats      Show statistics (--tools for MCP telemetry)
             sweep      Run maintenance/pruning
             uninstall  Remove ClaudeMemory configuration
             version    Show version number
 
+          Utilities:
+            completion     Generate shell completions (bash/zsh)
+            embeddings     Inspect embedding backend
+            git-lfs        Git LFS integration for memory DB
+            index          Build or rebuild content indexes
+            install-skill  Install agent skills to ~/.claude/commands/
+
           Run 'claude-memory <command> --help' for more information on a command.
         HELP
         0

data/lib/claude_memory/commands/hook_command.rb

@@ -171,13 +171,14 @@ module ClaudeMemory
 
       def hook_context(payload, db_path)
         project_path = payload["project_path"] || payload["cwd"]
+        source = payload["source"]
         manager = ClaudeMemory::Store::StoreManager.new(
           project_db_path: db_path,
           project_path: project_path
         )
         manager.ensure_both!
 
-        injector = ClaudeMemory::Hook::ContextInjector.new(manager)
+        injector = ClaudeMemory::Hook::ContextInjector.new(manager, source: source)
         context_text = injector.generate_context
 
         if context_text

data/lib/claude_memory/commands/index_command.rb

@@ -9,13 +9,14 @@ module ClaudeMemory
       SCOPE_PROJECT = "project"
 
       def call(args)
-        opts = parse_options(args, {scope: SCOPE_ALL, batch_size: 100, force: false, vec: false}) do |o|
+        opts = parse_options(args, {scope: SCOPE_ALL, batch_size: 100, force: false, vec: false, provider: nil}) do |o|
           OptionParser.new do |parser|
             parser.banner = "Usage: claude-memory index [options]"
             parser.on("--scope SCOPE", "Scope: global, project, or all (default: all)") { |v| o[:scope] = v }
             parser.on("--batch-size SIZE", Integer, "Batch size (default: 100)") { |v| o[:batch_size] = v }
             parser.on("--force", "Re-index facts that already have embeddings") { o[:force] = true }
             parser.on("--vec", "Backfill vec0 index from existing embeddings (no regeneration)") { o[:vec] = true }
+            parser.on("--provider NAME", "Embedding provider: tfidf, fastembed, api") { |v| o[:provider] = v }
           end
         end
         return 1 if opts.nil?
@@ -30,7 +31,7 @@ module ClaudeMemory
           return vec_backfill(opts)
         end
 
-        generator = Embeddings::Generator.new
+        generator = Embeddings.resolve(opts[:provider])
 
         scopes_for(opts[:scope]).each do |label, db_path|
           index_database(label, db_path, generator, opts)
@@ -42,9 +43,10 @@ module ClaudeMemory
       private
 
       def scopes_for(scope)
+        config = Configuration.new
         pairs = []
-        pairs << ["global", Configuration.global_db_path] if scope == SCOPE_ALL || scope == SCOPE_GLOBAL
-        pairs << ["project", Configuration.project_db_path] if scope == SCOPE_ALL || scope == SCOPE_PROJECT
+        pairs << ["global", config.global_db_path] if scope == SCOPE_ALL || scope == SCOPE_GLOBAL
+        pairs << ["project", config.project_db_path] if scope == SCOPE_ALL || scope == SCOPE_PROJECT
         pairs
       end
 
@@ -55,111 +57,85 @@ module ClaudeMemory
         end
 
         store = Store::SQLiteStore.new(db_path)
+        handle_dimension_mismatch(store, generator, label)
         tracker = Infrastructure::OperationTracker.new(store)
 
-        # Check for existing progress (resumption support)
+        facts, checkpoint = find_facts_to_index(store, tracker, label, opts)
+        unless facts
+          store.close
+          return
+        end
+
+        operation_id = checkpoint ? checkpoint[:operation_id] : tracker.start_operation(
+          operation_type: "index_embeddings",
+          scope: label,
+          total_items: facts.size,
+          checkpoint_data: {last_fact_id: nil}
+        )
+
+        stdout.puts "#{label.capitalize} database: Indexing #{facts.size} facts..."
+        run_indexing(store, facts, generator, tracker, operation_id, checkpoint, opts)
+      end
+
+      def handle_dimension_mismatch(store, generator, label)
+        check = Embeddings::DimensionCheck.call(store, generator)
+        return unless check.status == :mismatch
+
+        stdout.puts "#{label.capitalize}: Embedding dimensions changed (#{check.stored} → #{check.current}), clearing stale embeddings..."
+        clear_stale_embeddings(store)
+      end
+
+      def find_facts_to_index(store, tracker, label, opts)
         checkpoint = tracker.get_checkpoint(operation_type: "index_embeddings", scope: label)
+
         if checkpoint && !opts[:force]
           stdout.puts "#{label.capitalize} database: Resuming from previous run (processed #{checkpoint[:processed_items]} facts)..."
           resume_from_fact_id = checkpoint[:checkpoint_data][:last_fact_id]
-        else
-          resume_from_fact_id = nil
-        end
-
-        # Find facts to index
-        facts_dataset = if opts[:force]
-          store.facts
-        else
-          store.facts.where(embedding_json: nil)
-        end
-
-        # If resuming, skip facts we've already processed
-        if resume_from_fact_id
-          facts_dataset = facts_dataset.where(Sequel.lit("id > ?", resume_from_fact_id))
         end
 
+        facts_dataset = opts[:force] ? store.facts : store.facts.where(embedding_json: nil)
+        facts_dataset = facts_dataset.where(Sequel.lit("id > ?", resume_from_fact_id)) if resume_from_fact_id
         facts = facts_dataset.order(:id).all
 
         if facts.empty? && !checkpoint
           stdout.puts "#{label.capitalize} database: All facts already indexed"
-          store.close
-          return
+          return nil
         elsif facts.empty? && checkpoint
-          # Resume found nothing left to do - mark as completed
           tracker.complete_operation(checkpoint[:operation_id])
           stdout.puts "#{label.capitalize} database: Resumed operation completed (nothing left to index)"
-          store.close
-          return
+          return nil
         end
 
-        # Start or continue operation tracking
-        operation_id = checkpoint ? checkpoint[:operation_id] : tracker.start_operation(
-          operation_type: "index_embeddings",
-          scope: label,
-          total_items: facts.size,
-          checkpoint_data: {last_fact_id: nil}
-        )
-
-        stdout.puts "#{label.capitalize} database: Indexing #{facts.size} facts..."
+        [facts, checkpoint]
+      end
 
+      def run_indexing(store, facts, generator, tracker, operation_id, checkpoint, opts)
         vec_index = store.vector_index
-        if vec_index.available?
-          stdout.puts "  sqlite-vec available, dual-writing to vec0 index"
-        end
+        stdout.puts "  sqlite-vec available, dual-writing to vec0 index" if vec_index.available?
 
-        # Build embedding cache from already-embedded facts for content-addressed dedup
         embedding_cache = build_embedding_cache(store)
         cache_hits = 0
-
         processed = checkpoint ? checkpoint[:processed_items] : 0
+
         begin
           facts.each_slice(opts[:batch_size]) do |batch|
-            # Wrap batch processing in transaction for atomicity
-            store.db.transaction do
-              batch.each do |fact|
-                # Generate text representation
-                text = build_fact_text(fact, store)
-
-                # Content-addressed dedup: reuse embedding if identical text exists
-                embedding = embedding_cache[text]
-                if embedding
-                  cache_hits += 1
-                else
-                  embedding = generator.generate(text)
-                  embedding_cache[text] = embedding
-                end
-
-                # Store embedding (JSON column)
-                store.update_fact_embedding(fact[:id], embedding)
-
-                # Dual-write to vec0 if available (insert_embedding manages vec_indexed_at)
-                vec_index.insert_embedding(fact[:id], embedding) if vec_index.available?
-
-                processed += 1
-              end
-
-              # Update checkpoint after batch commits
-              last_fact_id = batch.last[:id]
-              tracker.update_progress(
-                operation_id,
-                processed_items: processed,
-                checkpoint_data: {last_fact_id: last_fact_id}
-              )
-            end
-
+            cache_hits += process_batch(store, batch, generator, vec_index, embedding_cache)
+            processed += batch.size
+
+            tracker.update_progress(
+              operation_id,
+              processed_items: processed,
+              checkpoint_data: {last_fact_id: batch.last[:id]}
+            )
             stdout.puts "  Processed #{processed} facts..."
           end
 
-          if processed > 0
-            pct = (cache_hits > 0) ? "#{(cache_hits * 100.0 / processed).round(1)}%" : "0%"
-            stdout.puts "  Cache hits: #{cache_hits}/#{processed} (#{pct} dedup)"
-          end
-
-          # Mark operation as completed
+          report_dedup_stats(processed, cache_hits)
+          store.set_meta("embedding_dimensions", generator.dimensions.to_s)
+          store.set_meta("embedding_provider", generator.name)
           tracker.complete_operation(operation_id)
           stdout.puts "  Done!"
         rescue => e
-          # Mark operation as failed
           tracker.fail_operation(operation_id, e.message)
           stderr.puts "  Failed: #{e.message}"
           raise
@@ -168,6 +144,32 @@ module ClaudeMemory
         end
       end
 
+      def process_batch(store, batch, generator, vec_index, embedding_cache)
+        cache_hits = 0
+        store.db.transaction do
+          batch.each do |fact|
+            text = build_fact_text(fact, store)
+            embedding = embedding_cache[text]
+            if embedding
+              cache_hits += 1
+            else
+              embedding = generator.generate(text)
+              embedding_cache[text] = embedding
+            end
+            store.update_fact_embedding(fact[:id], embedding)
+            vec_index.insert_embedding(fact[:id], embedding) if vec_index.available?
+          end
+        end
+        cache_hits
+      end
+
+      def report_dedup_stats(processed, cache_hits)
+        return unless processed > 0
+
+        pct = (cache_hits > 0) ? "#{(cache_hits * 100.0 / processed).round(1)}%" : "0%"
+        stdout.puts "  Cache hits: #{cache_hits}/#{processed} (#{pct} dedup)"
+      end
+
       def vec_backfill(opts)
         scopes_for(opts[:scope]).each do |label, db_path|
           unless File.exist?(db_path)
@@ -244,6 +246,11 @@ module ClaudeMemory
         parts.join(" ")
       end
 
+      def clear_stale_embeddings(store)
+        store.facts.where(Sequel.~(embedding_json: nil)).update(embedding_json: nil, vec_indexed_at: nil)
+        store.vector_index.clear!
+      end
+
       def valid_scope?(scope)
         [SCOPE_ALL, SCOPE_GLOBAL, SCOPE_PROJECT].include?(scope)
       end

data/lib/claude_memory/commands/initializers/database_ensurer.rb

@@ -15,6 +15,10 @@ module ClaudeMemory
           @stdout.puts "✓ Global database: #{manager.global_db_path}"
           manager.ensure_project!
           @stdout.puts "✓ Project database: #{manager.project_db_path}"
+
+          backfill_distillation_metrics(manager.global_store, "global")
+          backfill_distillation_metrics(manager.project_store, "project")
+
           manager.close
         end
 
@@ -22,8 +26,20 @@ module ClaudeMemory
           manager = ClaudeMemory::Store::StoreManager.new
           manager.ensure_global!
           @stdout.puts "✓ Created global database: #{manager.global_db_path}"
+
+          backfill_distillation_metrics(manager.global_store, "global")
+
           manager.close
         end
+
+        private
+
+        def backfill_distillation_metrics(store, label)
+          backfilled = store.backfill_distillation_metrics!
+          if backfilled > 0
+            @stdout.puts "✓ Marked #{backfilled} pre-existing content items as distilled (#{label})"
+          end
+        end
       end
     end
   end