claude_memory 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00a7e67707543e2a5266200eab3a276a5b70d25a41ebbc8a5eab8767c44952a8
-  data.tar.gz: 261f86e807d5638739a7462872ae9f5472451afd7aea5496c1cf785b54a76dc6
+  metadata.gz: 9b42d582ddd17dd325f8048268c889d6c80c1ca9c229732da1a8d619279201af
+  data.tar.gz: 8853caacc212900483a4a3f9939e8261e18f53b886675f01b4c5a5b61a506d26
 SHA512:
-  metadata.gz: 79ffe3d19420ae16dd26e2083a45c3725be43fd955bf707e3a1e157e04d790821cd5d199b8c67ea713c354c82314a931af1883d260a430119f2eb72213d8cc16
-  data.tar.gz: 864fffbf37c36d63a3a72e19f56ce7f288c26b7d6b546e55338ea0fb61fc963fb99704be28124e33fbb49d5098c3997409ecdac13735fd9cd52253b545346f4b
+  metadata.gz: a65038105334c741d26c5e485da7565016ae670ed24f04d4c23b2bb00329d729ee3bfd91cf333ea36ad518937e40e4c95c4d0846bcb423984b0ec683fee59b5a
+  data.tar.gz: d94e2ce5fbd1ed496a0c56f094b7f1fbb01b9eb255c819a95b2ffe6ecf79ea9c1706408fd658b2bcaee19d440a87d45a1185a7e471cb05fc7c003d433d6e5808

data/.claude/rules/claude_memory.generated.md

@@ -1,21 +1,51 @@
-<!-- 
+<!--
   This file is auto-generated by claude-memory.
   Do not edit manually - changes will be overwritten.
-  Generated: 2026-02-05T18:27:44Z
+  Generated: 2026-04-15T17:38:20Z
 -->
 
 # Project Memory
 
 ## Current Decisions
 
+- MCP tool-call telemetry stores minimal columns (tool_name, duration_ms, result_count, scope, error_class) — deliberately no query_text or query_hash. YAGNI: hashes are write-only without the raw text, and raw text adds privacy concerns without clear value beyond existing shortcut tools (memory.decisions, memory.conventions).
 - From QMD 2026-02-02 restudy: adopt Claude Code plugin format, MCP structured content pattern, MCP query guide prompt, inline status checks. Carry forward sqlite-vec, RRF, docids, smart expansion from 2026-01-26. Reject custom fine-tuned models, LLM reranking, YAML collections.
 - From claude-supermemory study: adopt SessionStart hook context injection (hookSpecificOutput.additionalContext), tool-specific observation compression, and relative time formatting. Reject cloud storage dependency and no-test approach.
 
 ## Conventions
 
+- Never use Sequel.sqlite for DB reads; this gem only depends on extralite. Use Sequel.connect("extralite://#{db_path}") or SQLiteStore.new. Sequel.sqlite requires the ungem'd sqlite3 adapter and fails at runtime.
+- Two distinct tool_calls tables exist: tool_calls (v3) for transcript-observed Claude Code tool usage, and mcp_tool_calls (v13) for MCP server telemetry. Disjoint purposes, never join.
+- MCP tool-call telemetry is recorded via MCP::Telemetry wrapping Server#handle_tools_call. Writes to mcp_tool_calls table in the project DB. Swallows DB errors so telemetry never breaks a real tool response. Viewable via 'claude-memory stats --tools [--since DAYS]'.
+- mcp_tool_calls retention is 90 days, enforced by Sweep::Maintenance#prune_old_mcp_tool_calls wired into Sweeper#run!. Configurable via mcp_tool_call_retention_days in Maintenance DEFAULT_CONFIG.
+- CLAUDE_CONFIG_DIR env var overrides the default ~/.claude location for Configuration#global_db_path. Access via Configuration#claude_config_dir. Additive, backwards compatible.
+- Registry::COMMANDS stores {class:, description:} entries as the single source of truth for command name, class reference, and shell-completion description. Class constants stored directly (no const_get). Registry.descriptions feeds CompletionCommand; adding a new command requires updating only this hash.
+- Prefer do...end over braces when a block has repeated argument names, multiple expressions, or non-trivial body. Single-expression simple blocks can still use braces.
+- EXPECTED_HOOKS constant must stay in sync with events in HooksConfigurator#build_hooks_config. Adding a new hook event without updating EXPECTED_HOOKS causes false doctor warnings.
+- Tests using --db for hook context only set the project DB path. StoreManager still connects to the real global DB. Must stub Configuration to return a temp global path for isolation.
+- Version must be updated in three places: lib/claude_memory/version.rb, .claude-plugin/plugin.json, .claude-plugin/marketplace.json. Runtime code uses ClaudeMemory::VERSION dynamically.
+- Use module inclusion (not class extraction) to break up god objects — preserves public API so zero tests need modification
+- Configuration class has instance methods only — use Configuration.new.global_db_path, not Configuration.global_db_path. Stub with instance_double + allow(Configuration).to receive(:new).and_return(config)
+- OperationTracker.reset_stuck_operations only resets operations older than 24 hours (STALE_THRESHOLD_SECONDS). Tests must backdate started_at to trigger resets.
+- SCHEMA_VERSION constant lives in Store::SchemaManager module but is accessible as SQLiteStore::SCHEMA_VERSION via Ruby include-based constant lookup
 - MCP tools return dual content (text summary) + structuredContent (JSON) via TextSummary module and Server#handle_tools_call. Compact mode (compact: true) omits receipts for ~60% smaller responses.
 - ContentSanitizer strips system-reminder, local-command-caveat, command-message, command-name, command-args tags in addition to private/no-memory/secret/claude-memory-context.
 - Core::RelativeTime module provides progressive time formatting: just now → Xm ago → Xh ago → Xd ago → YYYY-MM-DD. Used in ResponseFormatter for *_ago fields.
 - MCP server registers memory_guide prompt via prompts/list and prompts/get endpoints. QueryGuide module holds prompt content.
 - Claude Code plugin with marketplace.json, skill definitions, MCP server bundling. 5,700+ stars, by Tobi Lütke. Custom fine-tuned query expansion (Qwen3-1.7B, SFT+GRPO). Dual content/structuredContent MCP pattern.
 - Cloud-backed Claude Code plugin (~1,195 LOC JavaScript) using Supermemory API for persistent memory across sessions. Uses hooks for SessionStart context injection and Stop transcript capture. No local database.
+
+## Technical Constraints
+
+- **Uses database**: sqlite
+
+## Additional Knowledge
+
+### Architecture
+
+- MCP::Tools: Thin 104-line dispatcher that includes 6 handler modules in mcp/handlers/: QueryHandlers, ShortcutHandlers, ContextHandlers, ManagementHandlers, StatsHandlers, SetupHandlers
+- Recall: 94-line facade delegating to @engine (DualEngine or LegacyEngine), both include shared QueryCore module with all store-level query logic
+- SQLiteStore: 386-line CRUD class that includes RetryHandler (retry/connection logic) and SchemaManager (migrations/version sync) modules
+- Embeddings: Pluggable providers via Embeddings.resolve(name, env:). Three providers: tfidf (default), fastembed, api. Duck-typed contract: name, dimensions, generate(text). ENV: CLAUDE_MEMORY_EMBEDDING_PROVIDER
+- Embeddings::DimensionCheck: Pure value object — DimensionCheck.call(store, provider) returns Data.define Result with :fresh/:match/:mismatch status. No side effects; caller decides how to handle mismatch.
+

data/.claude/settings.json

@@ -5,24 +5,33 @@
         "hooks": [
           {
             "type": "command",
-            "command": "claude-memory hook ingest",
-            "timeout": 10
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 5,
+            "statusMessage": "Saving memory..."
           }
         ]
       }
     ],
-    "SessionStart": [
+    "StopFailure": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "claude-memory hook ingest",
-            "timeout": 10
-          },
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 5,
+            "statusMessage": "Saving memory..."
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
           {
             "type": "command",
             "command": "claude-memory hook context",
-            "timeout": 5
+            "timeout": 5,
+            "statusMessage": "Loading memory..."
           }
         ]
       }
@@ -32,13 +41,15 @@
         "hooks": [
           {
             "type": "command",
-            "command": "claude-memory hook ingest",
-            "timeout": 30
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 30,
+            "statusMessage": "Saving memory..."
           },
           {
             "type": "command",
-            "command": "claude-memory hook sweep",
-            "timeout": 30
+            "command": "claude-memory hook sweep --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 30,
+            "statusMessage": "Sweeping memory..."
           }
         ]
       }
@@ -48,13 +59,52 @@
         "hooks": [
           {
             "type": "command",
-            "command": "claude-memory hook ingest",
-            "timeout": 30
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 30,
+            "statusMessage": "Saving memory..."
           },
           {
             "type": "command",
-            "command": "claude-memory hook sweep",
-            "timeout": 30
+            "command": "claude-memory hook sweep --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 30,
+            "statusMessage": "Sweeping memory..."
+          }
+        ]
+      }
+    ],
+    "TaskCompleted": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 10,
+            "statusMessage": "Saving memory..."
+          }
+        ]
+      }
+    ],
+    "TeammateIdle": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "claude-memory hook ingest --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 15,
+            "statusMessage": "Saving memory..."
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "idle_prompt",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "claude-memory hook sweep --db /Users/valentinostoll/src/claude_memory/.claude/memory.sqlite3",
+            "timeout": 10,
+            "statusMessage": "Sweeping memory..."
           }
         ]
       }

data/.claude/settings.local.json

@@ -48,8 +48,11 @@
       "Bash(claude-memory search:*)",
       "Bash(bundle exec:*)",
       "Skill(improve)",
-      "Skill(improve:*)"
+      "Skill(improve:*)",
+      "WebFetch(domain:arxiv.org)",
+      "mcp__memory__memory_conflicts"
     ]
   },
-  "enableAllProjectMcpServers": true
+  "enableAllProjectMcpServers": true,
+  "outputStyle": "memory-aware"
 }

data/.claude/skills/improve/SKILL.md

@@ -3,23 +3,88 @@ name: improve
 description: Incrementally implement feature improvements from docs/improvements.md with tests and atomic commits. Focuses on new functionality rather than refactoring.
 agent: general-purpose
 allowed-tools: Read, Grep, Edit, Write, Bash
+arguments:
+  - name: mode
+    description: "Execution mode: 'sub-agent' (default, sequential) or 'agent-team' (parallel via agent teams)"
+    required: false
+    default: "sub-agent"
 ---
 
 # Feature Improvements - Incremental Implementation
 
 Systematically implement feature improvements from `docs/improvements.md`, making tested, atomic commits for each feature addition.
 
+## Execution Modes
+
+This skill supports two modes, passed as the first argument:
+
+- **`sub-agent`** (default): A single agent works through improvements sequentially. Best for small batches (1-3 features) or features with dependencies.
+- **`agent-team`**: Spawns a coordinated team of agents that implement independent features in parallel. Best for larger batches (3+) of independent features.
+
+---
+
+## Mode: agent-team
+
+When invoked with `agent-team`, follow this process:
+
+### Step 1: Read and Assess Improvements
+
+Read `docs/improvements.md` and identify all implementable features using the same feasibility criteria as sub-agent mode (skip Categories D-F, "Features to Avoid", "If Requested" items).
+
+### Step 2: Group Independent Features
+
+Partition implementable features into independent groups:
+- Features touching **different files** can be parallelized
+- Features sharing files or with dependencies must be sequential
+- Aim for 3-5 teammates maximum
+
+### Step 3: Create the Agent Team
+
+Create an agent team. For each teammate:
+
+1. **Assign one or two related features** per teammate
+2. **Provide full context** — teammates don't share your conversation history
+3. **Include these instructions for each teammate**:
+   - Read relevant existing code before making changes
+   - Follow the project's code style (Standard Ruby, frozen_string_literal)
+   - Write tests for all new functionality
+   - Run `bundle exec rake standard:fix` before committing
+   - Run relevant spec file after each edit, full suite before committing
+   - Run `bundle exec rspec` to verify all tests pass
+   - Make atomic commits with `[Feature]` prefix format
+   - Update `docs/improvements.md` to mark features as implemented
+   - Reference `.claude/skills/improve/feature-patterns.md` for implementation recipes
+
+### Step 4: Monitor and Coordinate
+
+- Wait for all teammates to complete their tasks
+- If a teammate reports a blocker or conflict, help resolve it
+- Do NOT implement tasks yourself — let teammates do the work
+
+### Step 5: Validate and Report
+
+After all teammates finish:
+
+1. Run the full test suite: `bundle exec rspec`
+2. Run the linter: `bundle exec rake standard:fix`
+3. If any failures, fix them or coordinate with the relevant teammate
+4. Provide a consolidated progress report (same Final Report format as sub-agent mode)
+
+---
+
+## Mode: sub-agent (default)
+
 ## Process Overview
 
 1. **Check memory health** by calling `memory.check_setup` to verify the system is operational
 2. **Read the improvements document** from `docs/improvements.md`
-2. **Identify unimplemented features** from "Remaining Tasks" section
-3. **Prioritize by stated priority** (Medium → Low)
-4. **Assess feasibility** (skip if too complex or requires external services)
-5. **Implement features incrementally** (one logical feature at a time)
-6. **Run tests after each change** to ensure nothing breaks
-7. **Make atomic commits** that capture the feature and its purpose
-8. **Update improvements.md** to mark features as implemented
+3. **Identify unimplemented features** from "Remaining Tasks" section
+4. **Prioritize by stated priority** (Medium → Low)
+5. **Assess feasibility** (skip if too complex or requires external services)
+6. **Implement features incrementally** (one logical feature at a time)
+7. **Run tests after each change** to ensure nothing breaks
+8. **Make atomic commits** that capture the feature and its purpose
+9. **Update improvements.md** to mark features as implemented
 
 ## Detailed Steps
 
@@ -100,11 +165,15 @@ For each feature:
    ```bash
    bundle exec rake standard:fix
    ```
-5. **Run tests**:
+5. **Run targeted tests** after each edit:
+   ```bash
+   bundle exec rspec spec/claude_memory/<relevant_spec>.rb
+   ```
+6. **Run full suite** before committing:
    ```bash
    bundle exec rspec
    ```
-6. **Fix any test failures** before proceeding
+7. **Fix any test failures** before proceeding
 
 ### Step 5: Make Atomic Commit
 
@@ -300,9 +369,15 @@ Is it marked "Features to Avoid"?
                 ↓
                 Category D (Background)?
                 ├─ YES → Assess carefully, may skip
-                └─ NO → Implement (Categories A-C safe)
+                └─ NO → Continue
                     ↓
-                    Implement the feature
+                    Does it have dependencies on other features?
+                    ├─ YES → Are dependencies complete?
+                    │   ├─ NO → SKIP, note dependency
+                    │   └─ YES → Continue
+                    └─ NO → Implement (Categories A-C safe)
+                        ↓
+                        Implement the feature
                     ↓
                     Run tests
                     ↓
@@ -324,11 +399,15 @@ Is it marked "Features to Avoid"?
 ## Time Budgets
 
 **Per Feature:**
-- Category A (Schema): Max 20 minutes
-- Category B (Reporting): Max 30 minutes
-- Category C (CLI): Max 30 minutes
-- Category D (Background): Max 60 minutes (or skip)
-- Category E (External): Max 45 minutes (or skip)
+- Category A (Schema): Max 15 minutes — skip if stuck after 15
+- Category B (Reporting): Max 20 minutes — skip if stuck after 20
+- Category C (CLI): Max 30 minutes — skip if stuck after 30
+- Category D (Background): Max 45 minutes (or skip at first sign of daemon complexity)
+- Category E (External): Max 30 minutes (or skip at first sign of dependency issues)
+
+**Per Debug Cycle:**
+- Test failure fix: Max 15 minutes — if you can't fix it in 15 minutes, revert and skip
+- Understanding code: Max 10 minutes — if unclear after 10 minutes, skip and report
 
 **Session Total:** Max 2 hours
 
@@ -337,26 +416,35 @@ If time budget exceeded: SKIP remaining features and report.
 ## Testing Strategy
 
 ### Test Frequency
-- After schema changes: Run all specs
-- After new command: Run command specs + integration
-- After reporting changes: Run relevant specs
-- Before commit: Full test suite
+- After each file edit: Run the relevant spec file
+- After schema changes: Run `spec/claude_memory/store/`
+- After new command: Run `spec/claude_memory/commands/`
+- Before each commit: Full test suite
+- If >5 files changed: Full test suite immediately
 
 ### Test Commands
 ```bash
-# Specific command tests
-bundle exec rspec spec/claude_memory/commands/
+# Single relevant spec (fastest feedback)
+bundle exec rspec spec/claude_memory/commands/metrics_command_spec.rb
 
-# Schema tests
+# Module-level specs
+bundle exec rspec spec/claude_memory/commands/
 bundle exec rspec spec/claude_memory/store/
 
-# Full suite
+# Full suite (before commit)
 bundle exec rspec
 
-# With linting
+# With linting (final check)
 bundle exec rake
 ```
 
+### Test Failure Response
+1. Read error message carefully
+2. Check if your change caused it (vs pre-existing)
+3. If your change: fix within 15 minutes or revert and skip
+4. If pre-existing: note and continue
+5. If unsure: revert change and skip item
+
 ### New Feature Tests
 
 Always add tests for new features:

data/.claude/skills/upgrade-dependencies/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: upgrade-dependencies
+description: "Upgrade all Ruby gem dependencies to their latest versions with release note review and codebase alignment checks. Use this skill whenever the user asks to update, upgrade, or bump dependencies, gems, or packages — even casually like 'update my gems' or 'are my deps up to date?'"
+agent: general-purpose
+allowed-tools: Read, Grep, Glob, Bash, Edit, Write, Agent, WebFetch
+---
+
+# Dependency Upgrade Skill
+
+Systematically upgrade Ruby gem dependencies by researching latest versions, reviewing release notes for breaking changes, updating version constraints, verifying with tests, and confirming codebase alignment.
+
+The goal is a *thoughtful* upgrade — not blindly bumping versions, but understanding what changed and ensuring the codebase is compatible. This matters because a silent API change can introduce bugs that tests don't catch if the tests don't exercise the affected code path.
+
+## Process Overview
+
+1. **Discover** current dependencies and their constraints
+2. **Research** latest versions and release notes (in parallel)
+3. **Analyze** breaking changes and codebase impact
+4. **Upgrade** version constraints and install
+5. **Verify** with the full test suite
+6. **Report** a summary table with upgrade details
+
+## Step 1: Discover Current Dependencies
+
+Read the gemspec and Gemfile to build a complete dependency inventory.
+
+```
+Read *.gemspec        → runtime dependencies (add_dependency)
+Read Gemfile          → development dependencies (gem declarations)
+Run: bundle outdated  → current vs latest versions, which are constrained
+```
+
+Build a working list with these columns:
+- **Gem name**
+- **Source** (gemspec or Gemfile)
+- **Current constraint** (e.g., `~> 5.0`)
+- **Installed version** (from `bundle outdated` or `Gemfile.lock`)
+- **Latest version** (from `bundle outdated`)
+- **Constrained?** (is the version constraint preventing upgrade?)
+
+## Step 2: Research Release Notes
+
+For each gem that has a newer version available, research what changed. Launch these as parallel Agent subagents — one per gem — to avoid sequential delays.
+
+Each research agent should:
+
+1. Run `gem search <name> --exact --versions` to confirm the latest version
+2. Fetch the changelog or release notes from GitHub (check CHANGELOG.md, CHANGES, HISTORY.md, or GitHub Releases)
+3. Summarize changes between the installed version and latest version
+4. Flag any **breaking changes**, **deprecations**, or **API changes**
+5. Note if it's a **major version bump** (higher risk)
+
+For transitive dependencies (not directly declared but showing in `bundle outdated`), research is optional — focus on direct dependencies. Transitive deps are upgraded automatically when their parent gem allows it.
+
+### What to look for in release notes
+
+- **Removed methods or classes** the codebase might use
+- **Renamed options or changed defaults** that could silently alter behavior
+- **New required arguments** to methods we call
+- **Deprecated features** we rely on (working now, but will break later)
+- **Changed return types** or data structures
+- **Minimum Ruby version bumps** that could affect CI or deployment
+
+## Step 3: Analyze Codebase Impact
+
+For each gem with breaking changes or API modifications:
+
+1. **Grep the codebase** for usage of affected APIs
+2. **Check test coverage** — are the affected code paths tested?
+3. **Determine if changes are needed** before or after the upgrade
+
+Classify each upgrade:
+
+- **Safe** — no breaking changes, or breaking changes don't affect our usage
+- **Needs code changes** — our code uses a deprecated or removed API
+- **Held back** — a transitive dependency constraint prevents the upgrade (explain which parent gem and why)
+
+If code changes are needed, make them *before* bumping the version constraint so the upgrade commit is clean.
+
+## Step 4: Upgrade Dependencies
+
+### Gemspec dependencies (runtime)
+
+Update version constraints to target the latest version. Use `~>` with the appropriate precision:
+
+- For stable gems (1.0+): `~> X.Y` allows patch updates (e.g., `~> 5.102` allows 5.102.x)
+- For pre-1.0 gems: `~> 0.X, ">= 0.X.Y"` to pin a minimum while allowing patches
+- For gems where a specific fix matters: add `">= X.Y.Z"` as an additional constraint
+
+### Gemfile dependencies (development)
+
+Same approach. If a major version bump is available (e.g., lefthook 1.x → 2.x), check the migration guide before bumping.
+
+### Install
+
+```bash
+bundle update
+```
+
+If `bundle update` fails due to dependency conflicts, resolve them. Common strategies:
+- Relax an overly tight constraint
+- Update the conflicting parent gem first
+- Accept that a gem can't be upgraded yet and document why
+
+## Step 5: Verify with Tests
+
+Run the full test suite:
+
+```bash
+bundle exec rspec
+```
+
+Also run the linter to catch any style issues:
+
+```bash
+bundle exec rake standard
+```
+
+If tests fail:
+1. Read the failure carefully — is it caused by the upgrade or pre-existing?
+2. If caused by the upgrade, fix the code to work with the new version
+3. If unfixable, revert that specific gem's upgrade and note it in the report
+
+## Step 6: Present Summary
+
+Present a clear summary table of all changes:
+
+```markdown
+| Gem | Old Version | New Version | Old Constraint | New Constraint | Notes |
+|-----|------------|-------------|----------------|----------------|-------|
+| sequel | 5.100.0 | 5.102.0 | ~> 5.0 | ~> 5.102 | No breaking changes |
+| lefthook | 1.13.6 | 2.1.4 | ~> 1.6 | ~> 2.1 | Major version bump, reviewed migration guide |
+```
+
+Follow the table with:
+
+1. **Breaking changes found** — what changed and how the codebase was updated
+2. **Gems held back** — which gems couldn't be upgraded and why (e.g., "diff-lcs 2.0 held back by rspec's ~> 1.4 constraint")
+3. **Notable new features** — anything worth adopting from the new versions
+4. **Test results** — confirmation that all tests pass
+
+## Edge Cases
+
+### Gems with no GitHub repository
+Fall back to `gem info <name>` and the RubyGems page for release history. Note reduced confidence in the review.
+
+### Yanked versions
+If `bundle update` fails because a version was yanked, try the next most recent version.
+
+### Pre-release versions
+Do not upgrade to pre-release or alpha versions unless the user explicitly asks. Stick to stable releases.
+
+### Monorepo gems
+Some gems (like rails components) are versioned together. Upgrade them as a group.

data/.claude-plugin/commands/distill-transcripts.md

@@ -0,0 +1,98 @@
+# Distill Transcripts
+
+Extract structured knowledge (facts, entities, decisions) from undistilled transcript content and persist it to long-term memory.
+
+## Usage
+
+```
+/distill-transcripts
+/distill-transcripts --limit 10
+```
+
+## Instructions
+
+You are a knowledge extraction specialist. Your job is to read raw transcript content and extract structured facts, entities, and decisions, then persist them via the memory.store_extraction MCP tool.
+
+### Step 1: Get Undistilled Content
+
+Call `memory.undistilled` with `limit: 10` to get transcript content that hasn't been processed yet.
+
+If no items are returned, report "No undistilled content found" and stop.
+
+### Step 2: Extract Knowledge (per item)
+
+For each content item, carefully read the raw_text and extract:
+
+**Entities** — Named things mentioned:
+- type: database, framework, language, platform, repo, module, person, service
+- name: Canonical name (e.g., "PostgreSQL" not "postgres")
+- confidence: 0.0-1.0
+
+**Facts** — Knowledge learned:
+- subject: Entity name or "repo" for project-level facts
+- predicate: uses_database, uses_framework, convention, decision, auth_method, deployment_platform, depends_on, testing_strategy
+- object: The value
+- confidence: 0.0-1.0
+- quote: Source excerpt (max 200 chars)
+- strength: "stated" (explicitly said) or "inferred" (implied)
+- scope_hint: "project" (this project only) or "global" (all projects)
+
+**Decisions** — Choices made:
+- title: Short summary (max 100 chars)
+- summary: Full description
+- status_hint: "accepted", "proposed", or "rejected"
+
+### What to Extract
+
+- Technology choices ("we use PostgreSQL", "switched to React")
+- Conventions ("always use frozen_string_literal", "test files go in spec/")
+- Architectural decisions ("API uses REST", "auth via JWT")
+- Preferences ("prefer 4-space indent", "use Standard Ruby")
+- Project structure ("migrations in db/migrations/", "commands in commands/")
+
+### What to Skip
+
+- Debugging steps and transient errors
+- Code output and tool observations
+- File contents that were just being read
+- Ephemeral task details ("fix this test", "run the linter")
+- Information already obvious from the codebase itself
+
+### Scope Detection
+
+Set scope_hint to "global" when the text contains signals like:
+- "I always...", "in all my projects...", "my preference is..."
+- "everywhere", "across all repos"
+
+Default to "project" for everything else.
+
+### Step 3: Persist Each Extraction
+
+For each content item with extracted knowledge:
+
+1. Call `memory.store_extraction` with the entities, facts, and decisions arrays
+2. Call `memory.mark_distilled` with the content_item_id and facts_extracted count
+3. If nothing was extracted, still call `memory.mark_distilled` with facts_extracted: 0
+
+### Step 4: Report
+
+Return a summary:
+
+```
+## Distillation Complete
+
+- Items processed: N
+- Facts extracted: N
+- Entities found: N
+- Decisions captured: N
+- Items skipped (nothing to extract): N
+```
+
+### Guidelines
+
+- Process items one at a time to keep extractions focused
+- Use `compact: true` on `memory.undistilled` for smaller responses
+- Be conservative — only extract facts you're confident about (>0.7)
+- Prefer "stated" strength over "inferred" unless clearly implied
+- Do NOT fabricate facts — only extract what's actually in the text
+- If text is mostly code/tool output with no conversational knowledge, mark as distilled with 0 facts