claude_memory 0.12.0 → 0.13.0

data/lib/claude_memory/commands/hook_command.rb

@@ -205,14 +205,26 @@ module ClaudeMemory
 
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         injector = ClaudeMemory::Hook::ContextInjector.new(manager, source: source)
-        context_text = injector.generate_context
+        # On PreCompact (context pressure) inject only the reflection nudge, not
+        # the full snapshot; everywhere else inject the full SessionStart context.
+        context_text = if payload["hook_event_name"] == "PreCompact"
+          injector.reflection_context
+        else
+          injector.generate_context
+        end
         duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round
 
         if context_text
           response = {
             hookSpecificOutput: {
               hookEventName: "SessionStart",
-              additionalContext: context_text
+              # Wrap in <claude-memory-context> so a later ingest strips our own
+              # injected snapshot back out (ContentSanitizer lists this tag in
+              # SYSTEM_TAGS). Without the wrapper, memory's injected facts and
+              # observation log leak into the transcript and get re-distilled —
+              # a self-ingestion feedback loop. Claude still reads the content;
+              # only the re-ingestion path treats it as strippable.
+              additionalContext: "<claude-memory-context>\n#{context_text}\n</claude-memory-context>"
             }
           }
           stdout.puts JSON.generate(response)
@@ -243,7 +255,8 @@ module ClaudeMemory
           top_fact_ids: injector.emitted_fact_ids.first(10),
           top_facts_by_scope: (by_scope if by_scope.any?),
           top_subjects: injector.emitted_subjects.uniq.first(10),
-          fact_count: injector.emitted_fact_ids.size
+          fact_count: injector.emitted_fact_ids.size,
+          observation_count: injector.emitted_observation_count
         }.compact
 
         ClaudeMemory::ActivityLog.record(store,

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

@@ -126,7 +126,9 @@ module ClaudeMemory
                   {"type" => "command", "command" => ingest_cmd, "timeout" => 30,
                    "statusMessage" => "Saving memory..."},
                   {"type" => "command", "command" => sweep_cmd, "timeout" => 30,
-                   "statusMessage" => "Sweeping memory..."}
+                   "statusMessage" => "Sweeping memory..."},
+                  {"type" => "command", "command" => context_cmd, "timeout" => 5,
+                   "statusMessage" => "Reflecting on memory..."}
                 ]
               }],
               "SessionEnd" => [{

data/lib/claude_memory/commands/install_skill_command.rb

@@ -15,6 +15,10 @@ module ClaudeMemory
         "distill-transcripts" => {
           file: "distill-transcripts.md",
           description: "Distill transcripts — extract facts/entities/decisions from undistilled content"
+        },
+        "reflect" => {
+          file: "reflect.md",
+          description: "Reflect on observations — consolidate the episodic log and promote corroborated observations to facts"
         }
       }.freeze
 

data/lib/claude_memory/commands/observations_command.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+
+module ClaudeMemory
+  module Commands
+    # CLI parity for the episodic observation layer — the "what happened" log
+    # that complements the semantic fact store ("what is true").
+    #
+    # Subcommands:
+    #   observations [list]   Summary: counts by status/kind/priority,
+    #                         corroboration + promotion readiness, compression
+    #                         ratio, and a recent timeline.
+    #   observations promote <id> --predicate P --object O [--subject S] [--scope ...]
+    #   observations consolidate <id1,id2,...> --body "<synthesis>" [--scope ...]
+    #
+    # The promote subcommand reuses the same corroboration gate and Resolver
+    # path as the memory.promote_observation MCP tool, so the anti-hallucination
+    # threshold is enforced identically across surfaces.
+    class ObservationsCommand < BaseCommand
+      def call(args)
+        subcommand = args.first
+        case subcommand
+        when "promote"
+          promote(args.drop(1))
+        when "consolidate"
+          consolidate(args.drop(1))
+        when "list", nil
+          list(args.drop(subcommand ? 1 : 0))
+        else
+          # Treat unknown first token as options to `list` (e.g. --json).
+          list(args)
+        end
+      end
+
+      private
+
+      # --- list (default) -----------------------------------------------------
+
+      def list(args)
+        opts = parse_options(args, {limit: 20, kind: nil, status: "active", scope: nil, json: false}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory observations [list] [options]"
+            parser.on("--limit N", Integer, "Max rows in the recent timeline (default: 20)") { |v| o[:limit] = v }
+            parser.on("--kind K", "Filter timeline by kind (e.g. decision, preference, event)") { |v| o[:kind] = v }
+            parser.on("--status S", "Filter timeline by status (active, consolidated, expired)") { |v| o[:status] = v }
+            parser.on("--scope SCOPE", %w[project global], "Limit to a single scope") { |v| o[:scope] = v }
+            parser.on("--json", "Emit machine-readable JSON") { o[:json] = true }
+          end
+        end
+        return 1 if opts.nil?
+
+        manager = ClaudeMemory::Store::StoreManager.new
+        stores = observation_stores(manager, opts[:scope])
+
+        report = build_report(stores, opts)
+        manager.close
+
+        if opts[:json]
+          stdout.puts(JSON.pretty_generate(report))
+        else
+          render_report(report)
+        end
+        0
+      end
+
+      def build_report(stores, opts)
+        {
+          totals: totals(stores),
+          by_kind: by_field(stores, :kind),
+          by_priority: by_field(stores, :priority),
+          corroboration: corroboration(stores),
+          compression: compression(stores),
+          recent: recent(stores, opts)
+        }
+      end
+
+      def render_report(report)
+        stdout.puts "Observations (episodic 'what happened' log)"
+        stdout.puts "=" * 50
+        stdout.puts
+
+        render_totals(report[:totals])
+        stdout.puts
+        render_breakdown("By kind (active)", report[:by_kind])
+        stdout.puts
+        render_priority(report[:by_priority])
+        stdout.puts
+        render_corroboration(report[:corroboration])
+        stdout.puts
+        render_compression(report[:compression])
+        stdout.puts
+        render_recent(report[:recent])
+      end
+
+      def render_totals(totals)
+        stdout.puts "Totals:"
+        stdout.puts "  Active: #{totals[:active]}"
+        stdout.puts "  Consolidated: #{totals[:consolidated]}"
+        stdout.puts "  Expired: #{totals[:expired]}"
+        stdout.puts "  Promoted: #{totals[:promoted]}"
+      end
+
+      def render_breakdown(title, counts)
+        stdout.puts "#{title}:"
+        if counts.empty?
+          stdout.puts "  (none)"
+          return
+        end
+        counts.sort_by { |_k, v| -v }.each do |key, count|
+          stdout.puts "  #{count.to_s.rjust(4)} - #{key}"
+        end
+      end
+
+      def render_priority(counts)
+        stdout.puts "By priority (active):"
+        if counts.empty?
+          stdout.puts "  (none)"
+          return
+        end
+        counts.sort_by { |priority, _v| priority }.each do |priority, count|
+          stdout.puts "  #{count.to_s.rjust(4)} - #{priority} (#{priority_label(priority)})"
+        end
+      end
+
+      def priority_label(priority)
+        case priority
+        when Domain::Observation::IMPORTANT then "important"
+        when Domain::Observation::MAYBE then "maybe"
+        else "info"
+        end
+      end
+
+      def render_corroboration(corroboration)
+        threshold = Domain::Observation::PROMOTION_THRESHOLD
+        stdout.puts "Corroboration:"
+        stdout.puts "  Max sightings: #{corroboration[:max]}"
+        stdout.puts "  Promotable (>= #{threshold} sightings, not yet promoted): #{corroboration[:promotable]}"
+      end
+
+      def render_compression(compression)
+        ratio = compression[:ratio]
+        stdout.puts "Compression:"
+        stdout.puts "  Observation tokens: #{compression[:observation_tokens]}"
+        stdout.puts "  Source tokens: #{compression[:source_tokens]}"
+        if ratio
+          stdout.puts "  Ratio (source / observation): #{ratio}x"
+        else
+          stdout.puts "  Ratio (source / observation): n/a"
+        end
+      end
+
+      def render_recent(recent)
+        stdout.puts "Recent timeline:"
+        if recent.empty?
+          stdout.puts "  (no observations)"
+          return
+        end
+        recent.each do |obs|
+          marker = priority_marker(obs[:priority])
+          stdout.puts "  ##{obs[:id]} #{marker} [#{obs[:kind]}] x#{obs[:corroboration_count]} (#{obs[:observed_ago]})"
+          stdout.puts "    #{obs[:body]}"
+        end
+      end
+
+      def priority_marker(priority)
+        case priority
+        when Domain::Observation::IMPORTANT then "[!]"
+        when Domain::Observation::MAYBE then "[~]"
+        else "[ ]"
+        end
+      end
+
+      # --- read aggregation (mirrors Dashboard::Observations) -----------------
+
+      def observation_stores(manager, scope)
+        scopes = scope ? [scope] : %w[project global]
+        scopes.filter_map { |s| manager.store_if_exists(s) }
+          .select { |store| store.db.table_exists?(:observations) }
+      end
+
+      def totals(stores)
+        {
+          active: count_where(stores, status: "active"),
+          consolidated: count_where(stores, status: "consolidated"),
+          expired: count_where(stores, status: "expired"),
+          promoted: stores.sum { |s| s.observations.exclude(promoted_at: nil).count }
+        }
+      end
+
+      def count_where(stores, **filter)
+        stores.sum { |s| s.observations.where(**filter).count }
+      end
+
+      def by_field(stores, field)
+        merged = Hash.new(0)
+        stores.each do |store|
+          store.observations.where(status: "active").group_and_count(field).each do |row|
+            merged[row[field]] += row[:count]
+          end
+        end
+        merged
+      end
+
+      def corroboration(stores)
+        threshold = Domain::Observation::PROMOTION_THRESHOLD
+        {
+          max: stores.map { |s| s.observations.where(status: "active").max(:corroboration_count) || 0 }.max || 0,
+          promotable: stores.sum do |s|
+            s.observations.where(status: "active", promoted_at: nil)
+              .where { corroboration_count >= threshold }.count
+          end
+        }
+      end
+
+      def compression(stores)
+        obs_tokens = stores.sum { |s| s.observations.where(status: "active").sum(:token_count) || 0 }
+        source_tokens = stores.sum { |s| source_tokens_for(s) }
+        ratio = obs_tokens.zero? ? nil : (source_tokens.to_f / obs_tokens).round(1)
+        {observation_tokens: obs_tokens, source_tokens: source_tokens, ratio: ratio}
+      end
+
+      def source_tokens_for(store)
+        ids = store.observations
+          .where(status: "active").exclude(source_content_item_id: nil)
+          .distinct.select(:source_content_item_id)
+          .map { |r| r[:source_content_item_id] }
+        return 0 if ids.empty?
+
+        bytes = store.content_items.where(id: ids).sum(:byte_len) || 0
+        (bytes / 4.0).round
+      end
+
+      def recent(stores, opts)
+        rows = stores.flat_map do |store|
+          dataset = store.observations
+          dataset = dataset.where(status: opts[:status]) if opts[:status]
+          dataset = dataset.where(kind: opts[:kind]) if opts[:kind]
+          dataset.order(Sequel.desc(:observed_at), Sequel.desc(:id)).limit(opts[:limit]).all
+        end
+
+        rows.sort_by { |o| o[:observed_at].to_s }.reverse.first(opts[:limit]).map do |o|
+          {
+            id: o[:id], kind: o[:kind], priority: o[:priority],
+            corroboration_count: o[:corroboration_count], body: o[:body],
+            observed_ago: Core::RelativeTime.format(o[:observed_at])
+          }
+        end
+      end
+
+      # --- promote ------------------------------------------------------------
+
+      def promote(args)
+        opts = parse_options(args, {predicate: nil, object: nil, subject: "repo", scope: "project"}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory observations promote <id> --predicate P --object O [options]"
+            parser.on("--predicate P", "Fact predicate (e.g. decision, convention)") { |v| o[:predicate] = v }
+            parser.on("--object O", "Fact object (the claim text)") { |v| o[:object] = v }
+            parser.on("--subject S", "Fact subject (default: repo)") { |v| o[:subject] = v }
+            parser.on("--scope SCOPE", %w[project global], "Database scope (default: project)") { |v| o[:scope] = v }
+          end
+        end
+        return 1 if opts.nil?
+
+        observation_id = parse_id(args.first)
+        return failure("Usage: claude-memory observations promote <id> --predicate P --object O") if observation_id.nil?
+        return failure("--predicate and --object are required") if opts[:predicate].nil? || opts[:object].to_s.strip.empty?
+
+        manager = ClaudeMemory::Store::StoreManager.new
+        store = manager.store_for_scope(opts[:scope])
+
+        result = promote_observation(store, observation_id, opts)
+        manager.close
+
+        return failure(result[:error]) if result[:error]
+
+        stdout.puts "Promoted observation ##{observation_id} -> fact ##{result[:fact_id]}"
+        stdout.puts "  #{result[:predicate]}: #{result[:object]}"
+        stdout.puts "  Corroboration: #{result[:corroboration_count]} sighting(s)"
+        0
+      end
+
+      # Server-side corroboration gate + Resolver path — the same logic the
+      # memory.promote_observation MCP handler uses. Returns {error:} on refusal
+      # or {fact_id:, predicate:, object:, corroboration_count:} on success.
+      def promote_observation(store, observation_id, opts)
+        obs = store.observations.where(id: observation_id).first
+        return {error: "Observation #{observation_id} not found in #{opts[:scope]} database."} unless obs
+        return {error: "Observation #{observation_id} already promoted (fact ##{obs[:promoted_fact_id]})."} unless obs[:promoted_at].nil?
+
+        threshold = Domain::Observation::PROMOTION_THRESHOLD
+        if obs[:corroboration_count].to_i < threshold
+          return {error: "Not yet corroborated: observation #{observation_id} has #{obs[:corroboration_count]} sighting(s), need #{threshold} (anti-hallucination gate)."}
+        end
+
+        occurred_at = Time.now.utc.iso8601
+        project_path = (opts[:scope] == "global") ? nil : Configuration.new.project_dir
+        extraction = Distill::Extraction.new(
+          facts: [{subject: opts[:subject], predicate: opts[:predicate], object: opts[:object], strength: "derived"}]
+        )
+        result = Resolve::Resolver.new(store).apply(
+          extraction, content_item_id: obs[:source_content_item_id],
+          occurred_at: occurred_at, project_path: project_path, scope: opts[:scope]
+        )
+
+        fact_id = result[:fact_ids].compact.first
+        return {error: "Promotion failed: the fact for observation #{observation_id} could not be resolved."} unless fact_id
+
+        store.mark_observation_promoted(observation_id, fact_id: fact_id)
+
+        {
+          fact_id: fact_id,
+          predicate: Resolve::PredicatePolicy.canonicalize(opts[:predicate]),
+          object: opts[:object],
+          corroboration_count: obs[:corroboration_count]
+        }
+      end
+
+      # --- consolidate --------------------------------------------------------
+
+      def consolidate(args)
+        opts = parse_options(args, {body: nil, kind: "event", priority: Domain::Observation::INFO, scope: "project"}) do |o|
+          OptionParser.new do |parser|
+            parser.banner = "Usage: claude-memory observations consolidate <id1,id2,...> --body \"<synthesis>\" [options]"
+            parser.on("--body TEXT", "The synthesized observation text") { |v| o[:body] = v }
+            parser.on("--kind K", "Kind for the merged observation (default: event)") { |v| o[:kind] = v }
+            parser.on("--scope SCOPE", %w[project global], "Database scope (default: project)") { |v| o[:scope] = v }
+          end
+        end
+        return 1 if opts.nil?
+
+        from_ids = parse_id_list(args.first)
+        return failure("Usage: claude-memory observations consolidate <id1,id2,...> --body \"<synthesis>\"") if from_ids.size < 2
+        return failure("--body is required") if opts[:body].to_s.strip.empty?
+
+        manager = ClaudeMemory::Store::StoreManager.new
+        store = manager.store_for_scope(opts[:scope])
+        project_path = (opts[:scope] == "global") ? nil : Configuration.new.project_dir
+
+        result = store.consolidate_observations(
+          from_ids, body: opts[:body].strip, kind: opts[:kind],
+          priority: opts[:priority], scope: opts[:scope], project_path: project_path
+        )
+        manager.close
+
+        return failure("Need at least 2 active #{opts[:scope]} observations from that set to consolidate.") if result.nil?
+
+        stdout.puts "Consolidated #{result[:merged]} observations -> ##{result[:id]}"
+        stdout.puts "  Combined corroboration: #{result[:corroboration_count]} sighting(s)"
+        0
+      end
+
+      # --- parsing helpers ----------------------------------------------------
+
+      def parse_id(token)
+        return nil if token.nil? || !token.match?(/\A\d+\z/)
+        token.to_i
+      end
+
+      def parse_id_list(token)
+        return [] if token.nil?
+        token.split(",").map(&:strip).select { |t| t.match?(/\A\d+\z/) }.map(&:to_i).uniq
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/registry.rb

@@ -37,6 +37,7 @@ module ClaudeMemory
         "completion" => {class: CompletionCommand, description: "Generate shell completions"},
         "embeddings" => {class: EmbeddingsCommand, description: "Inspect embedding backend"},
         "reject" => {class: RejectCommand, description: "Mark a fact as rejected"},
+        "observations" => {class: ObservationsCommand, description: "Inspect, promote, or consolidate episodic observations"},
         "restore" => {class: RestoreCommand, description: "Restore superseded facts from obsolete single-value classification"},
         "dedupe-conflicts" => {class: DedupeConflictsCommand, description: "Deduplicate historical open conflict rows that describe the same pair"},
         "reclassify-references" => {class: ReclassifyReferencesCommand, description: "Retag existing convention facts that match reference-material heuristics"},
@@ -45,6 +46,7 @@ module ClaudeMemory
         "digest" => {class: DigestCommand, description: "Render a weekly markdown digest of memory activity"},
         "show" => {class: ShowCommand, description: "Print what memory would inject at the next SessionStart"},
         "otel" => {class: OtelCommand, description: "Configure or inspect OpenTelemetry ingestion from Claude Code"},
+        "setup-vectors" => {class: SetupVectorsCommand, description: "Opt into vector recall — write provider env to .claude/settings.json + re-index"},
         "import-auto-memory" => {class: ImportAutoMemoryCommand, description: "Import Claude Code auto-memory .md files into project DB as facts"},
         "audit" => {class: AuditCommand, description: "Run memory health audit; report inconsistencies and optimizations"}
       }.freeze

data/lib/claude_memory/commands/setup_vectors_command.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "optparse"
+
+module ClaudeMemory
+  module Commands
+    # Guides the user through opting into vector recall with fastembed
+    # (or another provider). fastembed stays a dev/test gem dependency by
+    # design; this command is the documented opt-in path for end users.
+    #
+    # Steps:
+    #   1. Verify the chosen provider is loadable. For fastembed, surface
+    #      a clear install command if the gem isn't on $LOAD_PATH.
+    #   2. Persist CLAUDE_MEMORY_EMBEDDING_PROVIDER (and optional model)
+    #      into the project's .claude/settings.json env block, the same
+    #      mechanism Claude Code uses for OTel env (see OTel::SettingsWriter).
+    #   3. Re-embed existing facts under the new provider (unless --no-reindex).
+    #   4. Report the final state — provider, dimensions, stored alignment.
+    class SetupVectorsCommand < BaseCommand
+      OWNED_KEYS = %w[
+        CLAUDE_MEMORY_EMBEDDING_PROVIDER
+        CLAUDE_MEMORY_EMBEDDING_MODEL
+      ].freeze
+
+      FASTEMBED_INSTALL_HINT = <<~HINT
+        fastembed is not installed. claude-memory keeps fastembed as a
+        dev/test dependency so the default gem install stays light. To
+        enable it, install the gem and re-run setup-vectors:
+
+          gem install fastembed
+          claude-memory setup-vectors
+
+        Or if you bundle, add to your Gemfile:
+
+          gem "fastembed"
+
+        Then `bundle install` and re-run setup-vectors. The first run
+        downloads the BAAI/bge-small-en-v1.5 ONNX model (~75MB).
+      HINT
+
+      def call(args)
+        opts = parse_opts(args)
+        return 1 if opts.nil?
+
+        return print_status if opts[:status]
+
+        provider_name = opts[:provider]
+        unless verify_provider_loadable(provider_name)
+          return 1
+        end
+
+        if opts[:dry_run]
+          stdout.puts "Would write to #{settings_path}:"
+          stdout.puts "  CLAUDE_MEMORY_EMBEDDING_PROVIDER=#{provider_name}"
+          stdout.puts "  CLAUDE_MEMORY_EMBEDDING_MODEL=#{opts[:model]}" if opts[:model]
+          stdout.puts(opts[:reindex] ? "Would re-index facts under the new provider" : "Would skip re-index (--no-reindex)")
+          return 0
+        end
+
+        write_settings(provider_name, opts[:model])
+
+        if opts[:reindex]
+          reindex_result = reindex(provider_name)
+          return 1 if reindex_result != 0
+        else
+          stdout.puts "Skipped re-index (--no-reindex). Run 'claude-memory index --force --provider=#{provider_name}' when ready."
+        end
+
+        report_final_state(provider_name)
+        0
+      end
+
+      private
+
+      def parse_opts(args)
+        options = {provider: "fastembed", model: nil, reindex: true, dry_run: false, status: false}
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: claude-memory setup-vectors [--provider=fastembed|api|tfidf] [--model=NAME] [--no-reindex] [--dry-run] [--status]"
+          o.on("--provider NAME", "Embedding provider (default: fastembed)") { |v| options[:provider] = v }
+          o.on("--model NAME", "Optional model name (e.g. BAAI/bge-small-en-v1.5)") { |v| options[:model] = v }
+          o.on("--no-reindex", "Skip re-embedding existing facts under the new provider") { options[:reindex] = false }
+          o.on("--dry-run", "Print what would change without writing or re-indexing") { options[:dry_run] = true }
+          o.on("--status", "Show the current provider config + stored alignment, then exit") { options[:status] = true }
+        end
+        parser.parse!(args.dup)
+        options
+      rescue OptionParser::InvalidOption => e
+        stderr.puts e.message
+        nil
+      end
+
+      def verify_provider_loadable(provider_name)
+        case provider_name
+        when "tfidf"
+          true # always available
+        when "fastembed"
+          require "fastembed"
+          true
+        when "api"
+          # api provider needs network + key but no gem; defer to runtime
+          true
+        else
+          stderr.puts "Unknown provider: #{provider_name}. Valid: tfidf, fastembed, api."
+          false
+        end
+      rescue LoadError
+        stderr.puts FASTEMBED_INSTALL_HINT
+        false
+      end
+
+      def settings_path
+        File.join(claude_dir, "settings.json")
+      end
+
+      def claude_dir
+        File.join(Configuration.new.project_dir, ".claude")
+      end
+
+      def write_settings(provider_name, model)
+        FileUtils.mkdir_p(claude_dir)
+        settings = load_settings
+        settings["env"] ||= {}
+        settings["env"]["CLAUDE_MEMORY_EMBEDDING_PROVIDER"] = provider_name
+        if model
+          settings["env"]["CLAUDE_MEMORY_EMBEDDING_MODEL"] = model
+        else
+          settings["env"].delete("CLAUDE_MEMORY_EMBEDDING_MODEL")
+        end
+        File.write(settings_path, JSON.pretty_generate(settings) + "\n")
+        stdout.puts "✓ Wrote CLAUDE_MEMORY_EMBEDDING_PROVIDER=#{provider_name} to #{settings_path}"
+        stdout.puts "✓ Wrote CLAUDE_MEMORY_EMBEDDING_MODEL=#{model}" if model
+      end
+
+      def load_settings
+        return {} unless File.exist?(settings_path)
+        raw = File.read(settings_path)
+        return {} if raw.strip.empty?
+        parsed = JSON.parse(raw)
+        parsed.is_a?(Hash) ? parsed : {}
+      rescue JSON::ParserError => e
+        stderr.puts "settings.json parse error: #{e.message} — refusing to overwrite"
+        {}
+      end
+
+      def reindex(provider_name)
+        stdout.puts "→ Re-embedding facts under provider=#{provider_name}…"
+        IndexCommand.new(stdout: stdout, stderr: stderr).call(["--force", "--provider", provider_name])
+      end
+
+      def report_final_state(provider_name)
+        # The settings.json write only affects future sessions (Claude Code
+        # reads the env block at session start). For the current process
+        # the ENV var isn't set, so report what Embeddings.resolve would
+        # produce under the new env.
+        env_override = ENV.to_h.merge("CLAUDE_MEMORY_EMBEDDING_PROVIDER" => provider_name)
+        provider = Embeddings.resolve(provider_name, env: env_override)
+        stdout.puts
+        stdout.puts "Provider: #{provider.name}, dimensions: #{provider.dimensions}"
+        stdout.puts "Next session will use this provider. Run 'claude-memory doctor' to verify."
+      end
+
+      def print_status
+        # Resolve under current ENV to show what the next session will use
+        provider = Embeddings.resolve
+        stdout.puts "Current provider:   #{provider.name}"
+        stdout.puts "Current dimensions: #{provider.dimensions}"
+        stdout.puts "Settings file:      #{settings_path}"
+        env = load_settings.fetch("env", {})
+        relevant = env.slice(*OWNED_KEYS)
+        if relevant.any?
+          stdout.puts "Configured env:"
+          relevant.each { |k, v| stdout.puts "  #{k}=#{v}" }
+        else
+          stdout.puts "Configured env:     (none — using default tfidf)"
+        end
+        0
+      end
+    end
+  end
+end