robot_lab-durable 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bb9d48a0a10a6b049f34cb71625023be6373e403eae36b7964434443b9f74f2
-  data.tar.gz: b96330d170840c4e06b8ad349855e642bef12c4cb97b4a1b2d43fce0235df847
+  metadata.gz: b576c8ce4dc5ca5b4741cf6b7d9a95b0b653b9f54ab15aa02e0114a2e7cf43d4
+  data.tar.gz: 5079f8bd4f6a63fdcc9938da446db749ca1e93ab844aa5d47c4a8fbd025d189f
 SHA512:
-  metadata.gz: 36b8be5148c65454a058575065f92692466bf4a5a28f6fbc77e5fca39aa1ffce9dda7f368a15dc23a5a93e480b72ae40d9e5bf892419692c75bfee6dbb3a49fc
-  data.tar.gz: a162fdc17422a862537fb826ff0260fffb66de5143eb37da28362d06834bc4efa66b322a9b8984fe653690f87cd5c230806dc1441c67e3d5720f04a96d8eade2
+  metadata.gz: 7834ab27785b8f43f52e67dad700dd9a5a886cb0fb265d84e46b4cc79c0e123b5181847d17e87260400d6c3db3ac2212507ae7205186f684a6b8962270f49b57
+  data.tar.gz: cc57c77b81eaf328a07d167dc5d053dff56599935e51ada19fc50ac39bb73a73c1f63c28d387d77e3380693871b20e4e33c787cd9a2c39cd6d8734add3e8f19f

data/.rubocop.yml

@@ -0,0 +1,173 @@
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 4.0
+  Exclude:
+    - 'examples/**/*'
+    - 'vendor/**/*'
+    - 'dead_code/**/*'
+
+# ── Style: disabled cops ───────────────────────────────────────────────────
+Style/StringLiterals:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+# Ruby 4.0 freezes string literals by default
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/MultilineTernaryOperator:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/EmptyClassDefinition:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/RescueStandardError:
+  Enabled: false
+
+Style/OneClassPerFile:
+  Enabled: false
+
+# Both % and format/sprintf are acceptable
+Style/FormatString:
+  Enabled: false
+
+# String concatenation and interpolation are both acceptable
+Style/StringConcatenation:
+  Enabled: false
+
+# ── Layout ─────────────────────────────────────────────────────────────────
+Layout/LineLength:
+  Max: 140
+
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/HashAlignment:
+  Enabled: false
+
+Layout/FirstHashElementIndentation:
+  Enabled: false
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false
+
+# ── Naming ─────────────────────────────────────────────────────────────────
+# Single-char params (c, e, n) are acceptable throughout
+Naming/MethodParameterName:
+  Enabled: false
+
+Naming/VariableNumber:
+  Exclude:
+    - 'test/**/*'
+
+Naming/RescuedExceptionsVariableName:
+  Enabled: false
+
+# set_results and similar explicit setters are clear and conventional
+Naming/AccessorMethodName:
+  Enabled: false
+
+
+# has_tool_calls? and similar are clear and conventional
+Naming/PredicatePrefix:
+  Enabled: false
+
+# Test helper methods don't need to follow predicate naming rules
+Naming/PredicateMethod:
+  Exclude:
+    - 'test/**/*'
+
+# ── Lint: relax noisy cops on intentional patterns ─────────────────────────
+# Library and framework methods commonly accept args for API/documentation purposes
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+
+Lint/EmptyBlock:
+  Exclude:
+    - 'test/**/*'
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'Rakefile'
+    - 'test/**/*'
+
+# ── Gemspec ────────────────────────────────────────────────────────────────
+Gemspec/DevelopmentDependencies:
+  EnforcedStyle: Gemfile
+
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
+Gemspec/OrderedDependencies:
+  Enabled: false
+
+# ── Metrics ────────────────────────────────────────────────────────────────
+# Framework-level code (routers, parsers, orchestrators) is inherently complex.
+# Flog is the primary complexity gate — these RuboCop thresholds catch only
+# egregious outliers without false-positiving every dispatch method.
+
+Metrics/MethodLength:
+  Max: 35
+  CountAsOne:
+    - heredoc
+    - array
+    - hash
+  Exclude:
+    - 'test/**/*'
+
+Metrics/AbcSize:
+  Max: 40
+  Exclude:
+    - 'test/**/*'
+
+Metrics/ClassLength:
+  Max: 600
+  Exclude:
+    - 'test/**/*'
+
+Metrics/ModuleLength:
+  Max: 200
+  Exclude:
+    - 'test/**/*'
+
+Metrics/CyclomaticComplexity:
+  Max: 20
+  Exclude:
+    - 'test/**/*'
+
+Metrics/PerceivedComplexity:
+  Max: 20
+  Exclude:
+    - 'test/**/*'
+
+# Long method signatures with keyword args are a Ruby framework idiom
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+    - '*.gemspec'
+    - 'test/**/*'

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [0.2.1] - 2026-05-19
+
+### Added
+- `Durable::Entry` — immutable `Data.define` value object with `content`, `confidence`, `category`, `domain`, `use_count`, `created_at`, and `updated_at` fields
+- `Durable::Store` — YAML-backed, file-locked per-domain knowledge persistence in `~/.robot_lab/durable/`
+- `Durable::Reflector` — promotes session-level learnings into the durable store at end-of-run with confidence scoring and deduplication
+- `Durable::Learning` mixin — included into `RobotLab::Robot` when `learn: true` and `learn_domain:` constructor params are set
+- `RecallKnowledge` tool — lets robots query the durable store before making decisions
+- `RecordKnowledge` tool — lets robots write new knowledge entries during a session
+- Design document for future `DocumentStore::FileSystem` backend integration (`docs/document_store_backend_design.md`)
+
+### Changed
+- Version synchronized with robot_lab core 0.2.1
+
 ## [0.1.0] - 2026-05-07
 
 - Initial release

data/Rakefile

@@ -1,8 +1,116 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "minitest/test_task"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-Minitest::TestTask.create
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb', 'test/**/test_*.rb'].exclude('**/*_helper.rb')
+  t.verbose = true
+  t.ruby_opts << '-rtest_helper'
+end
 
 task default: :test
+
+desc 'Run tests with verbose output'
+task :test_verbose do
+  ENV['TESTOPTS'] = '--verbose'
+  Rake::Task[:test].invoke
+end
+
+desc 'Run a single test file'
+task :test_file, [:file] do |_t, args|
+  ruby "test/#{args[:file]}"
+end
+
+desc 'Check code style with RuboCop'
+task :rubocop do
+  sh 'bundle exec rubocop'
+end
+
+desc 'Auto-correct RuboCop offenses'
+task :rubocop_fix do
+  sh 'bundle exec rubocop -a'
+end
+
+desc 'Check code complexity with Flog (warn >=20, fail >=50)'
+task :flog_check do
+  require 'flog'
+
+  method_warn = 20.0
+  method_fail = 50.0
+
+  flogger = Flog.new(all: true)
+  flogger.flog(*Dir.glob('lib/**/*.rb'))
+
+  warnings = []
+  failures = []
+
+  flogger.each_by_score do |method, score|
+    next if method.end_with?('#none')
+
+    if score > method_fail
+      failures << "#{format('%.1f', score)}: #{method}"
+    elsif score > method_warn
+      warnings << "#{format('%.1f', score)}: #{method}"
+    end
+  end
+
+  unless warnings.empty?
+    puts "\nFlog warnings (#{method_warn}–#{method_fail}) — target for future refactoring:"
+    warnings.each { |v| puts "  #{v}" }
+  end
+
+  if failures.empty?
+    puts "\nFlog: no methods exceed the failure threshold (>=#{method_fail})"
+  else
+    puts "\nFlog failures (>=#{method_fail}) — must be refactored:"
+    failures.each { |v| puts "  #{v}" }
+    abort "\nFlog quality gate failed: #{failures.size} method(s) exceed #{method_fail}"
+  end
+end
+
+desc 'Run all quality checks: tests (with coverage), RuboCop, and Flog'
+task :quality do
+  results = {}
+
+  puts "\n#{'=' * 60}"
+  puts 'Quality Gate: Tests + Coverage'
+  puts '=' * 60
+  results[:tests] = system('bundle exec rake test') ? :pass : :fail
+
+  puts "\n#{'=' * 60}"
+  puts 'Quality Gate: RuboCop'
+  puts '=' * 60
+  results[:rubocop] = system('bundle exec rubocop') ? :pass : :fail
+
+  puts "\n#{'=' * 60}"
+  puts 'Quality Gate: Flog Complexity'
+  puts '=' * 60
+  results[:flog] = system('bundle exec rake flog_check') ? :pass : :fail
+
+  puts "\n#{'=' * 60}"
+  puts 'Quality Summary'
+  puts '=' * 60
+  results.each do |gate, status|
+    icon = status == :pass ? 'PASS' : 'FAIL'
+    puts "  [#{icon}] #{gate}"
+  end
+  puts '=' * 60
+
+  abort "\nQuality gate failed" if results.values.any?(:fail)
+  puts "\nAll quality gates passed."
+end
+
+namespace :docs do
+  desc 'Build MkDocs documentation'
+  task :build do
+    sh 'mkdocs build'
+  end
+
+  desc 'Serve MkDocs documentation locally on http://localhost:8000'
+  task :serve do
+    sh 'mkdocs serve'
+  end
+end

data/docs/document_store_backend_design.md

@@ -0,0 +1,42 @@
+# Delegate Storage to robot_lab-document_store — Design Discussion
+
+**Date:** 2026-05-14
+**Status:** Parked — resume when time allows
+
+## The Problem
+
+`robot_lab-durable` currently maintains its own `Store` class: a YAML-backed, file-locked, keyword-search storage layer in `lib/robot_lab/durable/store.rb`. This is duplicated effort — `robot_lab-document_store` is intended to be the canonical pluggable storage abstraction for the robot_lab ecosystem.
+
+## The Vision
+
+Once `robot_lab-document_store` gains a `DocumentStore::FileSystem` backend, durable should drop its custom `Store` class and delegate physical storage to it. Durable retains its own concerns:
+
+- `Entry` — immutable value object with confidence scoring, category, domain, use_count
+- `Reflector` — end-of-session promoter that pushes session learnings into the store
+- `Learning` — mixin included into `Robot` when robot_lab is present
+- `RecallKnowledge` / `RecordKnowledge` — LLM tools that interact with the store
+
+## What Changes in This Gem
+
+1. Add `robot_lab-document_store` as a runtime dependency in the gemspec.
+2. Remove `lib/robot_lab/durable/store.rb`.
+3. Wire `Learning#setup_durable_learning` to instantiate a `DocumentStore::FileSystem` instead of `Durable::Store`.
+4. Adapt `Reflector` and the two tools to call the `DocumentStore` interface (`store`, `search`, `delete`, etc.) rather than the old `Store` API.
+5. Handle `Entry` serialization — since `DocumentStore` stores raw text by key, durable will serialize `Entry` fields into text (or use a metadata hash if `FileSystem` supports it — see open questions).
+
+## Open Questions (shared with robot_lab-document_store)
+
+1. **Search semantics.** `DocumentStore::Memory` uses embedding-based cosine similarity; `DocumentStore::FileSystem` would use keyword matching. Should the interface declare its search capability, or do callers accept whatever the backend provides?
+
+2. **Structured vs raw text.** `Entry` carries structured fields (confidence, category, domain, use_count). Options:
+   - Durable serializes all fields into the stored text string; deserializes on recall.
+   - `DocumentStore::FileSystem` supports an optional `meta:` Hash alongside text, which durable populates with `Entry` fields.
+
+## Versioning
+
+- `robot_lab-document_store` must ship `DocumentStore::FileSystem` first — that is a v0.3.0 breaking change for that gem (v0.2.1 is the current release).
+- This gem (`robot_lab-durable`) then bumps to v0.3.0 once it drops `Store` and depends on document_store.
+
+## See Also
+
+`robot_lab-document_store/docs/pluggable_backends_design.md` — the full backend architecture design including the `DocumentStore` abstract interface and implementation plan.

data/lib/robot_lab/durable/entry.rb

@@ -2,16 +2,16 @@
 
 module RobotLab
   module Durable
-    Entry = Data.define(:content, :reasoning, :category, :domain, :confidence, :use_count, :created_at, :updated_at) do
-      CONFIDENCE_INCREMENT = 0.1
-      MAX_CONFIDENCE       = 1.0
+    CONFIDENCE_INCREMENT = 0.1
+    MAX_CONFIDENCE       = 1.0
 
+    Entry = Data.define(:content, :reasoning, :category, :domain, :confidence, :use_count, :created_at, :updated_at) do
       # Return a new Entry with confidence incremented and use_count bumped.
       def confirm
         new_confidence = [confidence + CONFIDENCE_INCREMENT, MAX_CONFIDENCE].min
         with(
           confidence: new_confidence.round(10),
-          use_count:  use_count + 1,
+          use_count: use_count + 1,
           updated_at: Time.now.iso8601
         )
       end
@@ -19,14 +19,14 @@ module RobotLab
       # Serialize to a plain Hash with string keys (safe for YAML round-trip).
       def to_h
         {
-          "content"    => content,
-          "reasoning"  => reasoning,
-          "category"   => category.to_s,
-          "domain"     => domain,
-          "confidence" => confidence,
-          "use_count"  => use_count,
-          "created_at" => created_at,
-          "updated_at" => updated_at
+          'content' => content,
+          'reasoning' => reasoning,
+          'category' => category.to_s,
+          'domain' => domain,
+          'confidence' => confidence,
+          'use_count' => use_count,
+          'created_at' => created_at,
+          'updated_at' => updated_at
         }
       end
 
@@ -34,14 +34,14 @@ module RobotLab
       def self.from_h(hash)
         h = hash.transform_keys(&:to_s)
         new(
-          content:    h["content"],
-          reasoning:  h["reasoning"],
-          category:   h["category"]&.to_sym,
-          domain:     h["domain"],
-          confidence: h["confidence"].to_f,
-          use_count:  h["use_count"].to_i,
-          created_at: h["created_at"],
-          updated_at: h["updated_at"]
+          content: h['content'],
+          reasoning: h['reasoning'],
+          category: h['category']&.to_sym,
+          domain: h['domain'],
+          confidence: h['confidence'].to_f,
+          use_count: h['use_count'].to_i,
+          created_at: h['created_at'],
+          updated_at: h['updated_at']
         )
       end
     end

data/lib/robot_lab/durable/reflector.rb

@@ -22,12 +22,12 @@ module RobotLab
           now = Time.now.iso8601
           @store.record(
             Entry.new(
-              content:    text,
-              reasoning:  "Observed during session (auto-promoted by Reflector)",
-              category:   :pattern,
-              domain:     @domain,
+              content: text,
+              reasoning: 'Observed during session (auto-promoted by Reflector)',
+              category: :pattern,
+              domain: @domain,
               confidence: 0.1,
-              use_count:  0,
+              use_count: 0,
               created_at: now,
               updated_at: now
             )

data/lib/robot_lab/durable/store.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "fileutils"
+require 'yaml'
+require 'fileutils'
 
 module RobotLab
   module Durable
     class Store
-      DEFAULT_PATH = File.join(Dir.home, ".robot_lab", "durable")
+      DEFAULT_PATH = File.join(Dir.home, '.robot_lab', 'durable')
 
       MIN_WORD_LENGTH = 3
 
@@ -77,13 +77,13 @@ module RobotLab
         file = domain_file(domain)
         return [] unless File.exist?(file)
 
-        raw = Array(YAML.safe_load(File.read(file)) || [])
+        raw = Array(YAML.safe_load_file(file) || [])
         raw.map { |h| Entry.from_h(h) }
       end
 
       def load_all
-        Dir.glob(File.join(@path, "*.yaml")).flat_map do |file|
-          raw = Array(YAML.safe_load(File.read(file)) || [])
+        Dir.glob(File.join(@path, '*.yaml')).flat_map do |file|
+          raw = Array(YAML.safe_load_file(file) || [])
           raw.map { |h| Entry.from_h(h) }
         end
       end
@@ -97,18 +97,19 @@ module RobotLab
           entries = load_domain(entry.domain)
           idx     = entries.find_index { |e| e.content.downcase == entry.content.downcase }
           raise RobotLab::Error, "Cannot confirm: entry not found in domain '#{entry.domain}'" unless idx
+
           entries[idx] = entry
           save_domain(entry.domain, entries)
         end
       end
 
       def domain_file(domain)
-        safe = domain.to_s.downcase.gsub(/[^a-z0-9]+/, "_").delete_prefix("_").delete_suffix("_")
+        safe = domain.to_s.downcase.gsub(/[^a-z0-9]+/, '_').delete_prefix('_').delete_suffix('_')
         File.join(@path, "#{safe}.yaml")
       end
 
       def with_domain_lock(domain, &block)
-        lock_path = domain_file(domain) + ".lock"
+        lock_path = "#{domain_file(domain)}.lock"
         File.open(lock_path, File::RDWR | File::CREAT, 0o644) do |f|
           f.flock(File::LOCK_EX)
           block.call

data/lib/robot_lab/durable/version.rb

@@ -2,6 +2,6 @@
 
 module RobotLab
   module Durable
-    VERSION = "0.1.0"
+    VERSION = '0.2.1'
   end
 end

data/lib/robot_lab/durable.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "durable/version"
-require_relative "durable/entry"
-require_relative "durable/store"
-require_relative "durable/reflector"
-require_relative "durable/learning"
+require_relative 'durable/version'
+require_relative 'durable/entry'
+require_relative 'durable/store'
+require_relative 'durable/reflector'
+require_relative 'durable/learning'
 
 # Minimal error stub so the storage layer works without robot_lab loaded.
 # When robot_lab is present its own RobotLab::Error takes precedence.
@@ -15,10 +15,12 @@ end
 # When robot_lab is loaded, register the knowledge tools and hook the
 # Learning mixin into Robot so `learn: true` works in the constructor.
 if defined?(RobotLab::Tool)
-  require_relative "recall_knowledge"
-  require_relative "record_knowledge"
+  require_relative 'recall_knowledge'
+  require_relative 'record_knowledge'
 end
 
-if defined?(RobotLab::Robot)
-  RobotLab::Robot.include(RobotLab::Durable::Learning)
+RobotLab::Robot.include(RobotLab::Durable::Learning) if defined?(RobotLab::Robot)
+
+if defined?(RobotLab) && RobotLab.respond_to?(:register_extension)
+  RobotLab.register_extension(:durable, RobotLab::Durable)
 end

data/lib/robot_lab/recall_knowledge.rb

@@ -2,17 +2,17 @@
 
 module RobotLab
   class RecallKnowledge < Tool
-    description "Recall relevant knowledge from past sessions before making a decision. " \
-                "Use this when uncertain whether to include or skip content, or when you want " \
-                "to check if you have seen a similar situation before. " \
-                "When in doubt and no relevant knowledge is found, skip the action."
+    description 'Recall relevant knowledge from past sessions before making a decision. ' \
+                'Use this when uncertain whether to include or skip content, or when you want ' \
+                'to check if you have seen a similar situation before. ' \
+                'When in doubt and no relevant knowledge is found, skip the action.'
 
-    param :query,  type: "string", desc: "Natural language description of the decision you are about to make"
-    param :domain, type: "string", desc: "Topic area to search (e.g. 'newsletter curation')", required: false
+    param :query,  type: 'string', desc: 'Natural language description of the decision you are about to make'
+    param :domain, type: 'string', desc: "Topic area to search (e.g. 'newsletter curation')", required: false
 
     def execute(query:, domain: nil)
       store = robot&.durable_store
-      return "No durable store configured on this robot." unless store
+      return 'No durable store configured on this robot.' unless store
 
       entries = store.recall(query: query, domain: domain, min_confidence: 0.0)
 
@@ -20,7 +20,7 @@ module RobotLab
         "No relevant past knowledge found for: #{query}. When in doubt, skip."
       else
         lines = entries.map do |e|
-          "[#{e.category}/conf:#{format("%.1f", e.confidence)}] #{e.content} — #{e.reasoning}"
+          "[#{e.category}/conf:#{format('%.1f', e.confidence)}] #{e.content} — #{e.reasoning}"
         end
 
         "Relevant past knowledge:\n#{lines.join("\n")}"

data/lib/robot_lab/record_knowledge.rb

@@ -2,28 +2,29 @@
 
 module RobotLab
   class RecordKnowledge < Tool
-    description "Record a piece of knowledge learned during this session. " \
-                "Use after a decision or discussion reveals something worth remembering: " \
-                "a user preference, a reliable pattern, or a factual insight. " \
-                "Recorded knowledge persists across future sessions."
+    description 'Record a piece of knowledge learned during this session. ' \
+                'Use after a decision or discussion reveals something worth remembering: ' \
+                'a user preference, a reliable pattern, or a factual insight. ' \
+                'Recorded knowledge persists across future sessions.'
 
-    param :content,   type: "string", desc: "The knowledge to record, in plain language (one clear statement)"
-    param :reasoning, type: "string", desc: "Why this is worth remembering — the observation or discussion that led to it"
-    param :category,  type: "string", desc: "One of: fact, preference, pattern, correction"
-    param :domain,    type: "string", desc: "Topic area this applies to (e.g. 'newsletter curation', 'ruby tooling')"
+    param :content,   type: 'string', desc: 'The knowledge to record, in plain language (one clear statement)'
+    param :reasoning, type: 'string',
+                      desc: 'Why this is worth remembering — the observation or discussion that led to it'
+    param :category,  type: 'string', desc: 'One of: fact, preference, pattern, correction'
+    param :domain,    type: 'string', desc: "Topic area this applies to (e.g. 'newsletter curation', 'ruby tooling')"
 
     def execute(content:, reasoning:, category:, domain:)
       store = robot&.durable_store
-      return "No durable store configured on this robot." unless store
+      return 'No durable store configured on this robot.' unless store
 
       now = Time.now.iso8601
       entry = Durable::Entry.new(
         content:,
         reasoning:,
-        category:   category.to_sym,
+        category: category.to_sym,
         domain:,
         confidence: 0.1,
-        use_count:  0,
+        use_count: 0,
         created_at: now,
         updated_at: now
       )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: robot_lab-durable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -13,16 +13,16 @@ dependencies:
   name: robot_lab
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
 description: Provides RobotLab::Durable — a YAML-backed knowledge store that lets
   robot_lab agents accumulate and recall observations across sessions. Includes Entry
   (immutable value object with confidence scoring), Store (file-locked per-domain
@@ -36,10 +36,12 @@ extra_rdoc_files: []
 files:
 - ".envrc"
 - ".github/workflows/deploy-github-pages.yml"
+- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/document_store_backend_design.md
 - docs/index.md
 - docs/superpowers/plans/2026-05-06-durable-learning.md
 - docs/superpowers/specs/2026-05-06-durable-learning-design.md