claude_memory 0.13.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '03389773428d20d899e3320e349cfd6a55e9c92df7b00837cf85466fe0741985'
-  data.tar.gz: 14c91b7778987ffd1acbf11b5b58c4ccf0ed7eda6f187534ea27b4dcc987bf67
+  metadata.gz: fef30295649f5cdb709f3650bbdfe7411ddccd566a906eaa09247a1b88f895a5
+  data.tar.gz: 3edd0ef999cb0c4356ef83c43e20646eed8cc8b68b9a2c8c1963191935eaaf98
 SHA512:
-  metadata.gz: b16bf521bfd7c496f4723a6029f981121ea2a76643eafb5045ab9528ab51543b47caf7d51474f21d69bb725e9544aa85c295ad303ee94cd7267f3d8cf4233184
-  data.tar.gz: a3d8a65e03d9c62fb7d4e2feb1ec37b32c9513eb13fe3c7c6488922192a842e67ac237562b186278948cb4e8ef9372a8e5f2d63c45ab34e9a6ac4604102ff0d7
+  metadata.gz: e23ad823124ffec0b84d81d6f309dbc601ef5c475f827d21cfd4f9f9dbb7172a2c4832ded63c6f38bf9f46f060c5c4e04d94fe2bd9e2ed0044f7da58c38c70a8
+  data.tar.gz: d71ff604a9518affc8d153574dba34361b9b54b49fbffac228ff00c076ce05971b698782551a17bbfc072c84ce4f16e44680857671469db9d1d0c08e87cd9f94

data/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
   "plugins": [
     {
       "name": "claude-memory",
-      "version": "0.13.1",
+      "version": "0.13.2",
       "source": "./",
       "description": "Long-term memory for Claude Code. Recalls architecture, conventions, and decisions across sessions, plus an episodic observation log of what happened — so Claude explains your codebase without file traversal, follows your patterns, learns from corrections, and never re-asks what it already learned.",
       "repository": "https://github.com/codenamev/claude_memory"

data/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Long-term memory for Claude Code. Recalls architecture, conventions, and decisions across sessions, plus an episodic observation log of what happened — so Claude explains your codebase without file traversal, follows your patterns, learns from corrections, and never re-asks what it already learned.",
   "author": {
     "name": "Valentino Stoll",

data/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.13.2] - 2026-06-27
+
+Theme: **Robustness from a real bug report (issue #7) + a 28MB→606K gem.** Closes [#7](https://github.com/codenamev/claude_memory/issues/7) — three independent failure modes around embeddings, FTS, and process lifecycle — plus two backlog items surfaced alongside it. No schema changes, no breaking changes.
+
+### Fixed
+
+- **Adopting a non-384-dim embedding model no longer hard-fails on an existing DB (#7 Finding 1).** The `facts_vec` vec0 table's width is immutable once created, and `embedding_dimensions` was only recorded *after* a successful index — so a tfidf/fresh DB silently created a 384 table and the first 768-dim insert raised `Expected 384 ... received 768`. `VectorIndex#recreate!` now drops + rebuilds `facts_vec` at the resolved width, and `IndexCommand#handle_dimension_mismatch` reads the table's actual width from its DDL and rebuilds up front (covering the unset-meta case, not just a recorded mismatch).
+- **Corrupt FTS5 rank index is now detected and self-heals (#7 Finding 2 + #69).** Concurrent writers can leave `content_fts` so that plain `MATCH` works but `ORDER BY rank` raises "database disk image is malformed" — silently breaking recall while `PRAGMA integrity_check` passes. `doctor` now probes the rank path per DB (`Checks::FtsRankCheck`); the sweep (`PreCompact`/`SessionEnd`) auto-rebuilds on detection (`Sweep::Maintenance#repair_fts_rank`) so recall self-repairs without a manual `compact`; and `LexicalFTS#search` raises a `CorruptRankIndexError` with a compact hint instead of an unhandled stacktrace.
+- **`serve-mcp` can no longer orphan (#7 Finding 3).** A hard kill of the client could leave the stdio MCP server blocked forever on `gets` (no stdin EOF), holding a SQLite connection — observed as serve-mcp processes lingering for days. A parent-death watchdog (`Server#orphaned?` + a 30s thread) exits the process once it's reparented away from its original parent.
+- **The embedding provider no longer leaks into the test suite.** `setup-vectors` wrote `CLAUDE_MEMORY_EMBEDDING_PROVIDER` into the tracked `settings.json`, which Claude Code injects into every subprocess env — flipping provider-dependent specs. It now writes to `settings.local.json` (per-machine), and the suite clears `CLAUDE_MEMORY_EMBEDDING_*` for hermetic runs.
+
+### Changed
+
+- **The published gem dropped from ~28MB to 606K (#71).** The gemspec's `git ls-files` manifest shipped the repo's own ~96MB dogfooding `.claude/memory.sqlite3` (and was trending toward RubyGems' 100MB ceiling). `.claude/` is now excluded from the manifest; users init their own DB, and the plugin manifest + commands/skills/output-styles (sourced at the top level) are unaffected. Regression-guarded by a manifest spec.
+
 ## [0.13.1] - 2026-06-23
 
 Theme: **The observational layer, audited and repaired.** A critical examination of every observation in a real (dogfooding) project DB found the episodic layer was producing ~no useful observations and injecting noise into sessions — three evidence-backed defects, now fixed (the data is in `docs/improvements.md` #72–#75). No schema changes, no breaking changes.

data/docs/improvements.md

@@ -294,6 +294,8 @@ Source: 2026-04-28 1.0 readiness review (`docs/1_0_punchlist.md` #6)
 
 ### 69. Self-Heal the FTS Rank Index After Concurrent Ingest
 
+**✅ Core shipped 2026-06-27** (detection + self-heal). **Proactive detection:** the doctor `Checks::FtsRankCheck` probes `MATCH … ORDER BY rank` per DB and flags corruption integrity_check misses (landed with issue #7 Finding 2, `2522044`). **Self-heal:** `Sweep::Maintenance#repair_fts_rank` probes the rank path each sweep (PreCompact/SessionEnd) and runs `LexicalFTS#rebuild!` on `malformed`, so recall self-repairs within the session that broke it — no manual `compact`. Also graceful: `LexicalFTS#search` now raises `CorruptRankIndexError` with a compact hint instead of a stacktrace. **Deferred:** the contention-reduction pragmas (busy_timeout + `BEGIN IMMEDIATE`) and the larger external-content-FTS5 redesign — they're risk/scope beyond the self-heal and not needed once the rank index auto-repairs.
+
 Source: 2026-06-16 live incident on `claude/observational-layer-design-7662r9` — observed first-hand, not a study.
 
 **Gap.** The contentless FTS5 index (`content_fts`) silently drifts into a broken state under concurrent writers: the ingest hook (`claude-memory hook ingest`) and the MCP server (`store_extraction` → `Index::LexicalFTS#index_content_item`) both write the same WAL DB, and a large ingest produces `"Database busy, retrying"` (`Store::RetryHandler`) followed by an FTS index where **plain `MATCH` works but `... ORDER BY rank` raises `database disk image is malformed`**. `integrity_check` passes and all rows are intact — so `recall`/`recall_index` ranking is silently degraded (the rank query throws or returns nothing) while nothing looks wrong. The only fix today is the user manually running `claude-memory compact` (which `rebuild_fts` + vacuums). Documented in `docs/influence/...` gotchas and surfaced reactively in the dashboard (`lib/claude_memory/dashboard/api.rb:338`), but never repaired automatically. Severe form (btree corruption, plain `MATCH` also failing) was separately seen when **two** memory MCP servers ran concurrently — de-duping to a single server removed that, but the benign rank-artifact still recurs from hook-vs-MCP contention alone.
@@ -506,6 +508,8 @@ Source: `docs/influence/mastra-observational-memory.md` — architecture study o
 
 ### 71. Exclude the project DB from the published gem (gem is 28MB, ~96MB of it the dogfooding DB)
 
+**✅ Shipped 2026-06-27.** Added `.claude/` to the gemspec reject filter; the published gem dropped from **28MB → 606K**. The plugin manifest (`.claude-plugin/`) and top-level `commands/`/`skills/`/`output-styles/` are preserved (the plugin sources them there, not from `.claude/`); runtime `.claude/output_styles` references resolve against the *user's* project dir. Regression-guarded by `spec/claude_memory/gemspec_manifest_spec.rb`.
+
 Source: 2026-06-18 live observation while building the 0.13.0 release gem.
 
 **Problem.** `claude_memory.gemspec` builds its file list from `git ls-files` and rejects `bin/ Gemfile .gitignore .rspec spec/ .github/ .standard.yml` — but **not** `.claude/memory.sqlite3`, which is tracked (per the "always commit the project DB" convention). So the published gem *ships the repo's own dogfooding memory database*: the working-tree DB is ~96MB, compressing to a **28MB gem** (v0.6.0 was 280KB; the gem has been silently growing — 0.9.1 was 19MB — as the DB accumulates). Gem users get nothing from it (they init their own empty DB on install), it bloats every download, and it's trending toward RubyGems' 100MB ceiling.

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ClaudeMemory
+  module Commands
+    module Checks
+      # Probes the FTS5 BM25 ranking path (`MATCH ... ORDER BY rank`) — exactly
+      # what recall issues. A contentless FTS5 index can corrupt such that plain
+      # MATCH, `SELECT count(*)`, and `PRAGMA integrity_check` all pass but
+      # `ORDER BY rank` raises "database disk image is malformed", silently
+      # breaking recall while every other check reports healthy (issue #7,
+      # Finding 2). Recoverable with `claude-memory compact`.
+      class FtsRankCheck
+        PROBE_TERM = "the" # extremely common; matches any non-trivial English corpus
+
+        def initialize(db_path, label)
+          @db_path = db_path
+          @label = label
+        end
+
+        def call
+          return skip_result unless File.exist?(@db_path)
+
+          store = Store::SQLiteStore.new(@db_path)
+          begin
+            Index::LexicalFTS.new(store).search(PROBE_TERM, limit: 1)
+            ok_result
+          ensure
+            store.close
+          end
+        rescue Index::LexicalFTS::CorruptRankIndexError
+          corrupt_result
+        rescue => e
+          # Anything unrelated (e.g. no FTS table) is not this check's concern.
+          {status: :ok, label: fts_label, message: "#{@label} FTS5 rank probe skipped: #{e.message}", details: {}}
+        end
+
+        private
+
+        def fts_label = "#{@label}_fts"
+
+        def ok_result
+          {status: :ok, label: fts_label, message: "#{@label} FTS5 rank path: healthy", details: {}}
+        end
+
+        def corrupt_result
+          {
+            status: :error,
+            label: fts_label,
+            message: "#{@label} FTS5 rank index is corrupt — recall is broken (integrity_check misses this). Run 'claude-memory compact' to rebuild.",
+            details: {}
+          }
+        end
+
+        def skip_result
+          {status: :ok, label: fts_label, message: "#{@label} FTS5: no database", details: {}}
+        end
+      end
+    end
+  end
+end

data/lib/claude_memory/commands/doctor_command.rb

@@ -22,6 +22,8 @@ module ClaudeMemory
           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::FtsRankCheck.new(manager.global_db_path, "global"),
+          Checks::FtsRankCheck.new(manager.project_db_path, "project"),
           Checks::VecCheck.new,
           Checks::EmbeddingsCheck.new,
           Checks::SnapshotCheck.new,

data/lib/claude_memory/commands/index_command.rb

@@ -77,12 +77,30 @@ module ClaudeMemory
         run_indexing(store, facts, generator, tracker, operation_id, checkpoint, opts)
       end
 
+      # Reconcile the vec0 table's width with the resolved provider before
+      # indexing (issue #7, Finding 1). The vec0 width is immutable once the
+      # table is created and was only recorded in meta *after* a successful run,
+      # so an old tfidf/fresh DB silently created a 384 table and the first
+      # non-384 insert hard-failed. We detect the table's actual width directly
+      # (not via the meta, which may be unset) and rebuild when it differs.
       def handle_dimension_mismatch(store, generator, label)
-        check = Embeddings::DimensionCheck.call(store, generator)
-        return unless check.status == :mismatch
+        target = generator.dimensions
+        # Record the resolved dimension up front so a fresh table is created at
+        # the right width on first insert, not left at the 384 default.
+        store.set_meta("embedding_dimensions", target.to_s)
+        store.set_meta("embedding_provider", generator.name)
 
-        stdout.puts "#{label.capitalize}: Embedding dimensions changed (#{check.stored} → #{check.current}), clearing stale embeddings..."
-        clear_stale_embeddings(store)
+        vec_index = store.vector_index
+        return unless vec_index.available?
+
+        actual = vec_index.table_dimensions
+        return if actual == target # table already at the right width
+
+        if actual # genuine change: existing facts must re-embed at the new width
+          stdout.puts "#{label.capitalize}: Embedding dimensions changed (#{actual} → #{target}), rebuilding vector table..."
+          clear_stale_embeddings(store)
+        end
+        vec_index.recreate!(target)
       end
 
       def find_facts_to_index(store, tracker, label, opts)

data/lib/claude_memory/commands/setup_vectors_command.rb

@@ -14,8 +14,8 @@ module ClaudeMemory
     #   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).
+    #      into the project's .claude/settings.local.json env block (per-machine,
+    #      gitignored — the provider is a developer choice, not a repo default).
     #   3. Re-embed existing facts under the new provider (unless --no-reindex).
     #   4. Report the final state — provider, dimensions, stored alignment.
     class SetupVectorsCommand < BaseCommand
@@ -110,8 +110,14 @@ module ClaudeMemory
         false
       end
 
+      # Write to settings.local.json (per-machine, gitignored), NOT the tracked
+      # settings.json: the embedding provider is a developer choice. Committing
+      # it would force the optional fastembed dependency on collaborators and —
+      # because Claude Code injects settings env into every subprocess — leak a
+      # non-default provider into the test suite, flipping provider-dependent
+      # specs (issue #7 follow-up, 2026-06-25).
       def settings_path
-        File.join(claude_dir, "settings.json")
+        File.join(claude_dir, "settings.local.json")
       end
 
       def claude_dir

data/lib/claude_memory/index/lexical_fts.rb

@@ -3,6 +3,15 @@
 module ClaudeMemory
   module Index
     class LexicalFTS
+      # Raised when the FTS5 BM25 ranking path fails as "malformed" while the
+      # rest of the DB is fine — a corrupt contentless FTS5 index that
+      # PRAGMA integrity_check misses (issue #7, Finding 2). Recoverable with
+      # `claude-memory compact` (which runs #rebuild!).
+      class CorruptRankIndexError < StandardError; end
+
+      RANK_CORRUPTION_HINT = "FTS5 rank index is corrupt — recall is broken even though " \
+        "the database otherwise looks healthy. Run `claude-memory compact` to rebuild it."
+
       def initialize(store)
         @store = store
         @db = store.db
@@ -35,17 +44,19 @@ module ClaudeMemory
         end
 
         escaped_query = escape_fts_query(query)
-        if contentless?
-          @db.fetch(
-            "SELECT rowid AS content_item_id FROM content_fts WHERE text MATCH ? ORDER BY rank LIMIT ?",
-            escaped_query, limit
-          ).map { |row| row[:content_item_id] }
-        else
-          @db[:content_fts]
-            .where(Sequel.lit("text MATCH ?", escaped_query))
-            .order(:rank)
-            .limit(limit)
-            .select_map(:content_item_id)
+        with_rank_index do
+          if contentless?
+            @db.fetch(
+              "SELECT rowid AS content_item_id FROM content_fts WHERE text MATCH ? ORDER BY rank LIMIT ?",
+              escaped_query, limit
+            ).map { |row| row[:content_item_id] }
+          else
+            @db[:content_fts]
+              .where(Sequel.lit("text MATCH ?", escaped_query))
+              .order(:rank)
+              .limit(limit)
+              .select_map(:content_item_id)
+          end
         end
       end
 
@@ -59,18 +70,20 @@ module ClaudeMemory
         return [] if query.strip == "*"
 
         escaped_query = escape_fts_query(query)
-        if contentless?
-          @db.fetch(
-            "SELECT rowid AS content_item_id, rank FROM content_fts WHERE text MATCH ? ORDER BY rank LIMIT ?",
-            escaped_query, limit
-          ).all
-        else
-          @db[:content_fts]
-            .where(Sequel.lit("text MATCH ?", escaped_query))
-            .order(:rank)
-            .limit(limit)
-            .select(Sequel.lit("content_item_id, rank"))
-            .all
+        with_rank_index do
+          if contentless?
+            @db.fetch(
+              "SELECT rowid AS content_item_id, rank FROM content_fts WHERE text MATCH ? ORDER BY rank LIMIT ?",
+              escaped_query, limit
+            ).all
+          else
+            @db[:content_fts]
+              .where(Sequel.lit("text MATCH ?", escaped_query))
+              .order(:rank)
+              .limit(limit)
+              .select(Sequel.lit("content_item_id, rank"))
+              .all
+          end
         end
       end
 
@@ -117,6 +130,17 @@ module ClaudeMemory
 
       private
 
+      # Run a `MATCH ... ORDER BY rank` query, translating the narrow
+      # "malformed"-on-rank failure into an actionable error instead of an
+      # unhandled Extralite stacktrace (issue #7, Finding 2). Any other error
+      # propagates unchanged.
+      def with_rank_index
+        yield
+      rescue => e
+        raise unless e.message.to_s.include?("malformed")
+        raise CorruptRankIndexError, RANK_CORRUPTION_HINT
+      end
+
       def contentless?
         @contentless
       end

data/lib/claude_memory/index/vector_index.rb

@@ -134,6 +134,33 @@ module ClaudeMemory
         true
       end
 
+      # Drop and rebuild facts_vec at `dimensions`. A vec0 column width is
+      # immutable once the table is created, so adopting a model of a different
+      # dimension (or any model on a DB whose table was created at the 384
+      # default) requires a full rebuild — clearing rows isn't enough (issue #7,
+      # Finding 1). Requires the sqlite-vec extension loaded so the vec0
+      # destructor runs on DROP.
+      # @param dimensions [Integer] new embedding width
+      def recreate!(dimensions)
+        return false unless available?
+
+        @dimensions = dimensions
+        @db.run("DROP TABLE IF EXISTS facts_vec")
+        @vec_table_ensured = false
+        ensure_vec_table!
+        true
+      end
+
+      # The width facts_vec was actually created with, parsed from its DDL — or
+      # nil when the table doesn't exist yet. Detects a stale-width table even
+      # when the embedding_dimensions meta was never written (old tfidf DBs),
+      # which is exactly the case that silently left a 384 table in place.
+      # @return [Integer, nil]
+      def table_dimensions
+        ddl = @db[:sqlite_master].where(type: "table", name: "facts_vec").get(:sql)
+        ddl && ddl[/embedding\s+float\[(\d+)\]/, 1]&.to_i
+      end
+
       # Number of entries in the vec0 virtual table
       def count
         return 0 unless available?

data/lib/claude_memory/mcp/server.rb

@@ -14,16 +14,19 @@ module ClaudeMemory
     # and writes JSON responses to output.
     class Server
       PROTOCOL_VERSION = "2024-11-05"
+      ORPHAN_CHECK_INTERVAL_SECONDS = 30
 
       # @param store_or_manager [Store::SQLiteStore, Store::StoreManager] database backend
       # @param input [IO] input stream for JSON-RPC requests (default: $stdin)
       # @param output [IO] output stream for JSON-RPC responses (default: $stdout)
-      def initialize(store_or_manager, input: $stdin, output: $stdout)
+      # @param parent_pid [Integer] pid to watch for orphaning (default: caller's parent)
+      def initialize(store_or_manager, input: $stdin, output: $stdout, parent_pid: Process.ppid)
         @store_or_manager = store_or_manager
         @tools = Tools.new(store_or_manager)
         @telemetry = Telemetry.new(store_or_manager)
         @input = input
         @output = output
+        @parent_pid = parent_pid
         @running = false
       end
 
@@ -31,12 +34,24 @@ module ClaudeMemory
       # @return [void]
       def run
         @running = true
+        watchdog = start_orphan_watchdog
         while @running
           line = @input.gets
           break unless line
 
           handle_message(line.strip)
         end
+      ensure
+        watchdog&.kill
+      end
+
+      # True once our original parent has exited and we've been reparented
+      # (to PID 1 / a subreaper). Claude Code spawns one stdio MCP server per
+      # session; a hard kill of the client can leave the server blocked on
+      # `gets` forever, holding a SQLite connection — the orphan leak in issue
+      # #7, Finding 3. The watchdog uses this to terminate.
+      def orphaned?
+        @parent_pid > 1 && Process.ppid != @parent_pid
       end
 
       # Signal the read loop to exit after the current message.
@@ -47,6 +62,23 @@ module ClaudeMemory
 
       private
 
+      # Background watch that terminates the process when the parent dies, since
+      # the read loop is otherwise blocked indefinitely on `gets`. Returns the
+      # Thread, or nil when there's no meaningful parent to watch (e.g. a test
+      # harness or a manually-launched server). Uses `exit!` because the orphaned
+      # parent is gone — there's nothing reading our output to flush to, and the
+      # OS releases the SQLite connection on process exit.
+      def start_orphan_watchdog
+        return if @parent_pid <= 1
+
+        Thread.new do
+          loop do
+            sleep ORPHAN_CHECK_INTERVAL_SECONDS
+            exit!(0) if orphaned?
+          end
+        end
+      end
+
       # @return [void]
       def handle_message(line)
         return if line.empty?

data/lib/claude_memory/sweep/maintenance.rb

@@ -408,6 +408,28 @@ module ClaudeMemory
         {deduped: result.deduped, expired: result.expired}
       end
 
+      # Self-heal the FTS5 rank index (improvement #69). Concurrent writers
+      # (the ingest hook vs the MCP server) can leave content_fts in a state
+      # where plain MATCH works but `ORDER BY rank` raises "malformed" —
+      # silently breaking recall while integrity_check passes. Sweep runs on
+      # PreCompact/SessionEnd, so probing the rank path here and rebuilding on
+      # failure lets recall self-repair within the session that broke it, with
+      # no manual `claude-memory compact`. (Detection is also surfaced by the
+      # doctor FtsRankCheck; this is the automatic repair.) A rebuild on a very
+      # large index runs to completion — corruption is rare and the rebuild is
+      # the only fix; the per-step budget gate keeps it from *starting* late.
+      # Returns: true if a rebuild was performed, false otherwise.
+      def repair_fts_rank
+        fts = ClaudeMemory::Index::LexicalFTS.new(@store)
+        fts.search("a", limit: 1)
+        false
+      rescue ClaudeMemory::Index::LexicalFTS::CorruptRankIndexError
+        fts.rebuild!
+        true
+      rescue
+        false
+      end
+
       # Run SQLite VACUUM to reclaim space.
       # Returns: true
       def vacuum

data/lib/claude_memory/sweep/sweeper.rb

@@ -57,6 +57,7 @@ module ClaudeMemory
           @stats[:observations_deduped] = reflection[:deduped]
           @stats[:observations_expired] = reflection[:expired]
         end
+        run_if_within_budget { @stats[:fts_rank_repaired] = maintenance.repair_fts_rank }
         run_if_within_budget { @stats[:wal_checkpointed] = maintenance.checkpoint_wal }
 
         @stats[:elapsed_seconds] = Time.now - @start_time

data/lib/claude_memory/version.rb

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

data/lib/claude_memory.rb

@@ -40,6 +40,7 @@ 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/checks/fts_rank_check"
 require_relative "claude_memory/commands/help_command"
 require_relative "claude_memory/commands/version_command"
 require_relative "claude_memory/commands/doctor_command"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude_memory
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - Valentino Stoll
@@ -90,30 +90,6 @@ files:
 - ".claude-plugin/scripts/hook-runner.sh"
 - ".claude-plugin/scripts/serve-mcp.sh"
 - ".claude.json"
-- ".claude/CLAUDE.md"
-- ".claude/memory.sqlite3"
-- ".claude/output-styles/memory-aware.md"
-- ".claude/rules/claude_memory.generated.md"
-- ".claude/settings.json"
-- ".claude/settings.local.json"
-- ".claude/skills/check-memory/DEPRECATED.md"
-- ".claude/skills/check-memory/SKILL.md"
-- ".claude/skills/dashboard/SKILL.md"
-- ".claude/skills/debug-memory"
-- ".claude/skills/improve/SKILL.md"
-- ".claude/skills/improve/feature-patterns.md"
-- ".claude/skills/memory-first-workflow"
-- ".claude/skills/quality-update/SKILL.md"
-- ".claude/skills/quality-update/implementation-guide.md"
-- ".claude/skills/release/SKILL.md"
-- ".claude/skills/review-commit/SKILL.md"
-- ".claude/skills/review-for-quality/SKILL.md"
-- ".claude/skills/review-for-quality/expert-checklists.md"
-- ".claude/skills/setup-memory"
-- ".claude/skills/study-repo/SKILL.md"
-- ".claude/skills/study-repo/analysis-template.md"
-- ".claude/skills/study-repo/focus-examples.md"
-- ".claude/skills/upgrade-dependencies/SKILL.md"
 - ".gitattributes"
 - ".lefthook/map_specs.rb"
 - ".mcp.json"
@@ -217,6 +193,7 @@ files:
 - lib/claude_memory/commands/checks/database_check.rb
 - lib/claude_memory/commands/checks/distill_check.rb
 - lib/claude_memory/commands/checks/embeddings_check.rb
+- lib/claude_memory/commands/checks/fts_rank_check.rb
 - lib/claude_memory/commands/checks/hooks_check.rb
 - lib/claude_memory/commands/checks/reporter.rb
 - lib/claude_memory/commands/checks/snapshot_check.rb

data/.claude/CLAUDE.md

@@ -1,4 +0,0 @@
-<!-- ClaudeMemory v0.7.0 -->
-# Project Memory
-
-@.claude/rules/claude_memory.generated.md

data/.claude/output-styles/memory-aware.md

@@ -1 +0,0 @@
-../../output-styles/memory-aware.md