claude_memory 0.7.0 → 0.7.1

data/lib/claude_memory/sweep/sweeper.rb

@@ -10,6 +10,10 @@ module ClaudeMemory
         default_budget_seconds: 5
       }.freeze
 
+      # Three-level escalation ensures sweep always makes progress.
+      # Source: lossless-claw three-level escalation pattern
+      ESCALATION_LEVELS = %i[normal aggressive fallback].freeze
+
       def initialize(store, config: {})
         @store = store
         @config = DEFAULT_CONFIG.merge(config)
@@ -24,16 +28,19 @@ module ClaudeMemory
           proposed_facts_expired: 0,
           disputed_facts_expired: 0,
           orphaned_provenance_deleted: 0,
-          old_content_pruned: 0
+          old_content_pruned: 0,
+          escalation_level: :normal
         }
 
-        expire_proposed_facts if within_budget?
-        expire_disputed_facts if within_budget?
-        prune_orphaned_provenance if within_budget?
-        prune_old_content if within_budget?
-        backfill_vec_index if within_budget?
-        cleanup_vec_expired if within_budget?
-        checkpoint_wal if within_budget?
+        maintenance = build_maintenance(:normal)
+
+        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[:orphaned_provenance_deleted] = maintenance.prune_orphaned_provenance }
+        run_if_within_budget { @stats[:old_content_pruned] = maintenance.prune_old_content }
+        run_if_within_budget { @stats[:vec_backfilled] = maintenance.backfill_vec_index }
+        run_if_within_budget { @stats[:vec_cleaned] = maintenance.cleanup_vec_expired }
+        run_if_within_budget { @stats[:wal_checkpointed] = maintenance.checkpoint_wal }
 
         @stats[:elapsed_seconds] = Time.now - @start_time
         @stats[:budget_honored] = @stats[:elapsed_seconds] <= budget
@@ -41,90 +48,89 @@ module ClaudeMemory
           message: "Sweep complete",
           elapsed_seconds: @stats[:elapsed_seconds].round(3),
           budget_honored: @stats[:budget_honored],
+          escalation_level: @stats[:escalation_level],
           proposed_expired: @stats[:proposed_facts_expired],
           disputed_expired: @stats[:disputed_facts_expired])
         @stats
       end
 
-      private
-
-      def within_budget?
-        budget = @config[:default_budget_seconds]
-        (Time.now - @start_time) < budget
-      end
+      # Run sweep with escalation: if normal sweep makes no progress,
+      # escalate to aggressive (halved TTLs), then fallback (force-expire oldest).
+      # Returns stats hash with :escalation_level indicating which level succeeded.
+      #
+      # Source: lossless-claw three-level escalation pattern
+      def run_with_escalation!(budget_seconds: nil)
+        stats = run!(budget_seconds: budget_seconds)
+        total = stats[:proposed_facts_expired] + stats[:disputed_facts_expired] +
+          stats[:orphaned_provenance_deleted] + stats[:old_content_pruned]
+
+        if total == 0
+          # Escalate to aggressive — halved TTLs
+          aggressive_maintenance = build_maintenance(:aggressive)
+          added = 0
+          added += aggressive_maintenance.expire_proposed_facts
+          added += aggressive_maintenance.expire_disputed_facts
+          added += aggressive_maintenance.prune_old_content
+
+          if added > 0
+            stats[:proposed_facts_expired] += added
+            stats[:escalation_level] = :aggressive
+          else
+            # Fallback — force-expire oldest proposed/disputed facts
+            fallback_count = force_expire_oldest
+            stats[:proposed_facts_expired] += fallback_count
+            stats[:escalation_level] = :fallback if fallback_count > 0
+          end
+
+          stats[:elapsed_seconds] = Time.now - @start_time
+        end
 
-      def expire_proposed_facts
-        cutoff = (Time.now - @config[:proposed_fact_ttl_days] * 86400).utc.iso8601
-        @stats[:proposed_facts_expired] = @store.facts
-          .where(status: "proposed")
-          .where { created_at < cutoff }
-          .update(status: "expired")
+        stats
       end
 
-      def expire_disputed_facts
-        cutoff = (Time.now - @config[:disputed_fact_ttl_days] * 86400).utc.iso8601
-        @stats[:disputed_facts_expired] = @store.facts
-          .where(status: "disputed")
-          .where { created_at < cutoff }
-          .update(status: "expired")
-      end
-
-      def prune_orphaned_provenance
-        fact_ids = @store.facts.select(:id)
-        @stats[:orphaned_provenance_deleted] = @store.provenance
-          .exclude(fact_id: fact_ids)
-          .delete
-      end
+      private
 
-      def prune_old_content
-        cutoff = (Time.now - @config[:content_retention_days] * 86400).utc.iso8601
-        referenced_ids = @store.provenance.exclude(content_item_id: nil).select(:content_item_id)
-        prunable = @store.content_items
-          .where { ingested_at < cutoff }
-          .exclude(id: referenced_ids)
-
-        # Remove FTS entries for content being pruned
-        fts = ClaudeMemory::Index::LexicalFTS.new(@store)
-        prunable.select(:id, :raw_text).each do |row|
-          fts.remove_content_item(row[:id], row[:raw_text])
-        rescue
-          # FTS entry may not exist; skip
+      def build_maintenance(level)
+        config = case level
+        when :aggressive
+          {
+            proposed_fact_ttl_days: @config[:proposed_fact_ttl_days] / 2,
+            disputed_fact_ttl_days: @config[:disputed_fact_ttl_days] / 2,
+            content_retention_days: @config[:content_retention_days] / 2
+          }
+        else
+          @config.slice(:proposed_fact_ttl_days, :disputed_fact_ttl_days, :content_retention_days)
         end
 
-        @stats[:old_content_pruned] = prunable.delete
+        Maintenance.new(@store, config: config)
       end
 
-      def with_vec_index
-        vec_index = @store.vector_index
-        return unless vec_index.available?
-        yield vec_index
-      end
-
-      def backfill_vec_index
-        with_vec_index do |vec_index|
-          @stats[:vec_backfilled] = vec_index.backfill_batch!(limit: 100)
-        end
+      # Force-expire the oldest proposed or disputed facts regardless of TTL.
+      # Guarantees progress when normal and aggressive sweeps find nothing.
+      # Limited to 10 facts per invocation for safety.
+      def force_expire_oldest(limit: 10)
+        oldest_ids = @store.facts
+          .where(status: %w[proposed disputed])
+          .order(:created_at)
+          .limit(limit)
+          .select(:id)
+          .map { |r| r[:id] }
+
+        return 0 if oldest_ids.empty?
+
+        @store.facts
+          .where(id: oldest_ids)
+          .update(status: "expired")
       end
 
-      def cleanup_vec_expired
-        with_vec_index do |vec_index|
-          # Remove vec0 entries for superseded/expired facts
-          # (remove_embedding manages vec_indexed_at)
-          stale_ids = @store.facts
-            .where(status: %w[superseded expired])
-            .where(Sequel.~(vec_indexed_at: nil))
-            .select(:id)
-            .limit(100)
-            .map { |r| r[:id] }
-
-          stale_ids.each { |fact_id| vec_index.remove_embedding(fact_id) }
-          @stats[:vec_cleaned] = stale_ids.size
-        end
+      def run_if_within_budget
+        return unless within_budget?
+        yield
       end
 
-      def checkpoint_wal
-        @store.checkpoint_wal
-        @stats[:wal_checkpointed] = true
+      def within_budget?
+        budget = @config[:default_budget_seconds]
+        (Time.now - @start_time) < budget
       end
     end
   end

data/lib/claude_memory/version.rb

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

data/lib/claude_memory.rb

@@ -116,6 +116,7 @@ require_relative "claude_memory/resolve/predicate_policy"
 require_relative "claude_memory/resolve/resolver"
 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/version"
 

data/v0.6.0.ANNOUNCE

@@ -0,0 +1,32 @@
+**ClaudeMemory v0.6.0 — Native Vector Search, Benchmarks, and Critical Bug Fixes**
+
+New release of ClaudeMemory, the long-term self-managed memory gem for Claude Code.
+
+**What's new:**
+
+**sqlite-vec Native Vector Storage** — Vector search is now backed by sqlite-vec for fast KNN queries instead of loading all embeddings into Ruby. Embeddings are dual-written to both JSON and vec0 virtual tables, with automatic fallback if sqlite-vec isn't available. The `doctor` command reports vec coverage and the sweeper cleans up stale entries.
+
+**SessionStart Context Injection** — Memory now automatically injects relevant facts at the start of each session via `hookSpecificOutput.additionalContext`, so Claude has context before you even ask.
+
+**Database Maintenance** — New `compact` (VACUUM + integrity check) and `export` (JSON backup) commands for database housekeeping.
+
+**Comparative Benchmarks (DevMemBench)** — Head-to-head retrieval benchmarks against QMD and grepai across 50 queries at 3 difficulty levels:
+
+```
+Adapter                  Recall@5   MRR
+QMD-Vector               0.842      0.930
+ClaudeMemory (hybrid)    0.712      0.732
+FTS-only                 0.712      0.732
+QMD-BM25                 0.350      0.400
+grepai                   0.000      0.000
+```
+
+QMD-Vector leads on easy/medium queries thanks to its custom fine-tuned query expansion model (Qwen3-1.7B). ClaudeMemory edges ahead on hard cross-category queries (0.358 vs 0.352 Recall@5) where multi-fact reasoning matters. Truth maintenance remains at 100% accuracy across all 100 test cases. Full benchmark suite runs locally at zero cost.
+
+**Critical Bug Fixes:**
+- **Recall returned no results** — `DualQueryTemplate` accessed stores before initializing them, silently returning empty arrays for all queries. This was the root cause of `claude-memory recall` never finding facts.
+- **Doctor crashed with `no such module: vec0`** — Schema health checks tried to count rows in sqlite-vec virtual tables without loading the extension first.
+
+21 MCP tools · 22 CLI commands · 1,316 tests
+
+<https://github.com/codenamev/claude_memory/releases/tag/v0.6.0>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude_memory
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Valentino Stoll
@@ -132,6 +132,7 @@ files:
 - docs/influence/episodic-memory.md
 - docs/influence/grepai.md
 - docs/influence/kbs.md
+- docs/influence/lossless-claw.md
 - docs/influence/qmd.md
 - docs/organizational_memory_playbook.md
 - docs/plans/feature_adoption_plan.md
@@ -238,6 +239,7 @@ files:
 - lib/claude_memory/ingest/tool_filter.rb
 - lib/claude_memory/ingest/transcript_reader.rb
 - lib/claude_memory/logging/logger.rb
+- lib/claude_memory/mcp/error_classifier.rb
 - lib/claude_memory/mcp/instructions_builder.rb
 - lib/claude_memory/mcp/query_guide.rb
 - lib/claude_memory/mcp/response_formatter.rb
@@ -256,6 +258,7 @@ files:
 - lib/claude_memory/shortcuts.rb
 - lib/claude_memory/store/sqlite_store.rb
 - lib/claude_memory/store/store_manager.rb
+- lib/claude_memory/sweep/maintenance.rb
 - lib/claude_memory/sweep/sweeper.rb
 - lib/claude_memory/templates/hooks.example.json
 - lib/claude_memory/templates/output-styles/memory-aware.md
@@ -269,6 +272,7 @@ files:
 - skills/memory-first-workflow/SKILL.md
 - skills/memory/SKILL.md
 - skills/setup-memory/SKILL.md
+- v0.6.0.ANNOUNCE
 homepage: https://github.com/codenamev/claude_memory
 licenses:
 - MIT