ima-claude 2.9.0

package/plugins/ima-claude/skills/mcp-serena/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: mcp-serena
+description: "Use Serena MCP for ALL code navigation and investigation — it saves 40-70% tokens vs reading files. Use INSTEAD of Read/Grep when exploring code structure: get_symbols_overview (structure without reading), find_symbol (locate any class/method/function), find_referencing_symbols (all callers). Triggers on: where is X used, find references, what calls X, rename X, refactor X, show X usage, track down X, what does class X look like, find the function, look up the method, explore this file, understand this code, how is X implemented. With PHPStorm+Serena: works across PHP, TypeScript, JS, Vue, Python."
+---
+
+# Serena MCP - Code Symbol Operations
+
+Use Serena for code symbol discovery and modification instead of reading entire files.
+
+## Setup: Direct Access
+
+Serena runs directly (not through Airis gateway). Tools are available as `mcp__serena__*`.
+
+## MCP Tools
+
+| Tool | Purpose |
+|------|---------|
+| `mcp__serena__jet_brains_find_symbol` | Find symbols by name path pattern |
+| `mcp__serena__jet_brains_find_referencing_symbols` | Find all references to a symbol |
+| `mcp__serena__rename_symbol` | Rename symbol across entire codebase |
+| `mcp__serena__jet_brains_get_symbols_overview` | Get top-level symbols in a file |
+| `mcp__serena__search_for_pattern` | Regex pattern search (better for Vue) |
+| `mcp__serena__list_dir` | List directory contents |
+
+## Workflow: Symbol Discovery
+
+### Find a Symbol
+
+```
+mcp__serena__jet_brains_find_symbol
+  name_path_pattern: "UserService"
+  include_body: false
+  depth: 1
+```
+
+- Use `depth: 1` to see methods/properties
+- Use `include_body: true` only when you need implementation details
+- Use `relative_path` to narrow search scope
+
+### Find All References
+
+```
+mcp__serena__jet_brains_find_referencing_symbols
+  name_path: "UserService/getUserData"
+  relative_path: "src/services/user.ts"
+  include_info: true
+```
+
+### Get File Overview
+
+```
+mcp__serena__jet_brains_get_symbols_overview
+  relative_path: "src/services/user.ts"
+  depth: 1
+```
+
+Better than reading entire file when you just need structure.
+
+## Workflow: Symbol Modification
+
+### Rename Symbol
+
+```
+mcp__serena__rename_symbol
+  name_path: "getUserData"
+  relative_path: "src/services/user.ts"
+  new_name: "fetchUserData"
+```
+
+Automatically updates all references across the codebase.
+
+## Gitignore Handling (Important)
+
+**Known Issue**: Serena has problems with complex `.gitignore` negation patterns (GitHub Issue #600).
+
+Example problem:
+```gitignore
+plugins/           # Ignored
+!plugins/custom/   # Re-included (but Serena may still ignore it)
+```
+
+Serena's `is_ignored_path()` returns `True` early, bypassing negation logic.
+
+### Workarounds
+
+**For `list_dir`** - use `skip_ignored_files: false`:
+```
+mcp__serena__list_dir
+  relative_path: "plugins"
+  recursive: true
+  skip_ignored_files: false
+```
+
+**For `search_for_pattern`** - target folder directly with `relative_path`:
+```
+mcp__serena__search_for_pattern
+  substring_pattern: "functionName"
+  relative_path: "plugins/custom"
+  context_lines_before: 2
+  context_lines_after: 2
+```
+
+**Alternative** - use explicit glob to include:
+```
+mcp__serena__search_for_pattern
+  substring_pattern: "functionName"
+  paths_include_glob: "**/plugins/**"
+```
+
+## Vue 3 / Quasar Projects
+
+**Important**: TypeScript LSP doesn't fully understand Vue 3 `<script setup>` syntax.
+
+For `.vue` files and `src/composables/`, prefer pattern search:
+
+```
+mcp__serena__search_for_pattern
+  substring_pattern: "import.*useAuth|from.*useAuth"
+  paths_include_glob: "**/*.vue"
+  context_lines_before: 2
+  context_lines_after: 2
+```
+
+**Decision Logic for Vue**:
+```
+IF target is .vue file OR src/composables/:
+    → Use search_for_pattern (more reliable)
+ELSE IF pure .ts/.js files:
+    → Use LSP tools (find_symbol, find_referencing_symbols)
+```
+
+## Decision Logic
+
+```
+IF need to find/understand code symbols:
+    → Use find_symbol, find_referencing_symbols
+ELSE IF need to rename/refactor symbol:
+    → Use rename_symbol (handles dependencies automatically)
+ELSE IF simple text pattern search:
+    → Use search_for_pattern
+ELSE IF searching in gitignore-negated folder:
+    → Use relative_path to target directly OR skip_ignored_files: false
+ELSE IF reading full file needed:
+    → Use native Read tool
+```
+
+## Error Recovery
+
+| Error | Recovery |
+|-------|----------|
+| Symbol not found | Try broader name_path_pattern, check spelling |
+| Vue SFC issues | Switch to search_for_pattern |
+| Gitignore blocking folder | Use relative_path directly or skip_ignored_files: false |
+| Rename failed | Check if symbol is in external dependency |
+| Too many results | Add relative_path to narrow scope |
+
+## When NOT to Use
+
+- Simple text searches (use Grep)
+- Reading configuration files (use Read)
+- Operations on non-code files (markdown, json, yaml)
+- When you need file content, not symbol info
+
+## Examples
+
+| User Request | Action |
+|--------------|--------|
+| "Where is UserService used?" | find_referencing_symbols(name_path: "UserService") |
+| "Rename getUserData to fetchUser" | rename_symbol(name_path: "getUserData", new_name: "fetchUser") |
+| "What methods does AuthService have?" | find_symbol(name_path: "AuthService", depth: 1) |
+| "Find useAuth usage in Vue files" | search_for_pattern(pattern: "useAuth", glob: "**/*.vue") |
+| "Search in plugins folder" | search_for_pattern(relative_path: "plugins/custom") |
+| "List plugins directory" | list_dir(relative_path: "plugins", skip_ignored_files: false) |
+| "Show me the user.ts file" | Native Read (full file needed) |

package/plugins/ima-claude/skills/mcp-tavily/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: mcp-tavily
+description: Use Tavily MCP for web research and current information beyond knowledge cutoff (post-January 2025). Triggers on 'latest', 'current', '2025', '2026', 'what's new', 'recent updates', 'modern approach', 'compare options', research questions requiring multiple sources, or any question about events/releases/changes after January 2025. Provides 60-70% token savings over multiple WebFetch calls.
+---
+
+# Tavily MCP - Web Research & Current Information
+
+Use Tavily for current information and research instead of multiple WebFetch calls.
+
+## MCP Tools
+
+| Tool | Purpose |
+|------|---------|
+| `mcp__tavily__search` | Web search with depth control |
+| `mcp__tavily__extract` | Extract content from specific URLs |
+
+## Basic Search
+
+```
+mcp__tavily__search
+  query: "Vue 4 new features 2026"
+  search_depth: "basic"
+  max_results: 10
+```
+
+**Key parameters**:
+- `query` (required): Search query string
+- `search_depth`: "basic" | "advanced" (default: "basic")
+- `max_results`: Number of results (default: 5)
+- `topic`: "general" | "news" (default: "general")
+- `days`: Limit results to last N days (optional)
+- `include_domains`: Array of domains to include (optional)
+- `exclude_domains`: Array of domains to exclude (optional)
+
+## Search Depth Selection
+
+| Depth | Use Case | Response Time |
+|-------|----------|---------------|
+| `basic` | Standard factual lookups, quick answers | Fast |
+| `advanced` | Comprehensive research, comparisons, multiple perspectives | Slower, more thorough |
+
+## Query Optimization
+
+**Effective queries**:
+- Include year: "React 19 features 2026"
+- Be specific: "Vite 6 breaking changes" not "Vite updates"
+- Add context: "TypeScript 5.5 new utility types"
+
+**Query patterns**:
+| Need | Query Pattern |
+|------|---------------|
+| Latest version features | "[library] [version] new features [year]" |
+| Breaking changes | "[library] [version] migration breaking changes" |
+| Comparisons | "[tool A] vs [tool B] comparison [year]" |
+| Best practices | "[topic] best practices [year]" |
+
+## Extract Content
+
+```
+mcp__tavily__extract
+  urls: ["https://example.com/article"]
+```
+
+Extracts clean content from specific URLs.
+
+## Decision Logic
+
+```
+IF question requires post-January-2025 information:
+    → Use Tavily
+ELSE IF research needs multiple web sources:
+    → Use Tavily
+ELSE IF single known URL needed:
+    → Use native WebFetch
+ELSE IF question within Claude's knowledge:
+    → Use native Claude
+ELSE IF asking about library API (not "what's new"):
+    → Use Context7 instead
+```
+
+## When NOT to Use
+
+- Library API documentation (use Context7)
+- Code symbol searches (use Serena)
+- Questions Claude already knows (pre-cutoff knowledge)
+- Single URL content extraction where native WebFetch works
+
+## Examples
+
+| User Request | Action |
+|--------------|--------|
+| "What's new in Vue 4?" | tavily search(query: "Vue 4 new features 2026", search_depth: "basic") |
+| "Compare Bun vs Node 2026" | tavily search(query: "Bun vs Node.js comparison 2026", search_depth: "advanced") |
+| "Latest Vite features" | tavily search(query: "Vite latest features 2026") |
+| "How does useState work?" | Native Claude (known knowledge) |
+| "Quasar QDialog API" | Use Context7 (library docs) |
+
+## Source Attribution
+
+After using Tavily, always include sources section:
+
+```
+Sources:
+- [Official Vue Blog](https://blog.vuejs.org/...)
+- [Release Notes](https://github.com/vuejs/...)
+```
+
+## Setup
+
+Requires Tavily API key. Install with:
+```bash
+bun run scripts/setup-mcp.ts
+```
+
+Or manually:
+```bash
+claude mcp add --scope user -e TAVILY_API_KEY=your-key -- tavily npx -y tavily-mcp@latest
+```

package/plugins/ima-claude/skills/mcp-vestige/SKILL.md

@@ -0,0 +1,259 @@
+---
+name: "mcp-vestige"
+description: "Cognitive memory engine with semantic search, spaced repetition, and codebase awareness. Replaces Memory MCP for all persistent knowledge: preferences, decisions, patterns, bugs, intentions. You MUST use this proactively - search at session start, store decisions as they happen, set intentions for future work. Triggers on: remember this, what did we decide, previously, last time, remind me, set intention, and always proactively."
+---
+
+# Vestige MCP - Cognitive Memory Engine
+
+**Replaces Memory MCP.** Vestige is a Rust-based cognitive memory system with FSRS-6 spaced repetition, semantic search, prediction error gating, and codebase awareness.
+
+## Architecture (3-Tier Memory)
+
+| System | Role | Lifecycle | Example |
+|--------|------|-----------|---------|
+| **Vestige** | Neural memory — decisions, preferences, patterns, bugs, learnings | Fades if unused (FSRS-6 decay) | "We chose JWT over sessions because..." |
+| **Qdrant** | Permanent library — reference material, standards, PRDs, architecture docs | Persistent forever | "Our payment system uses Accept.js with ARB" |
+| **Serena Memory** | Project workbench — session state, task progress | Project-scoped, survives git ops | "Currently on task 3/5, next: write tests" |
+
+## Session Start Protocol (REQUIRED)
+
+At session start, BEFORE asking questions:
+
+```
+mcp__vestige__search query: "{project-name}" limit: 5
+mcp__vestige__search query: "user-eric preferences" limit: 5
+mcp__vestige__intention action: "check"
+```
+
+If working in a Serena-activated project, also check:
+```
+mcp__serena__list_memories
+```
+
+## Core Tools
+
+### Search (Your Most-Used Tool)
+
+```
+mcp__vestige__search
+  query: "authentication decision"
+  limit: 5
+```
+
+Hybrid search — keyword + semantic + RRF fusion. Returns ranked results with similarity scores.
+
+### Smart Ingest (Intelligent Storage)
+
+```
+mcp__vestige__smart_ingest
+  content: "We chose Zod over Yup for validation because..."
+  node_type: "decision"
+```
+
+Automatically handles CREATE/UPDATE/SUPERSEDE based on similarity thresholds:
+
+| Similarity | Action | Meaning |
+|------------|--------|---------|
+| >92% | REINFORCE | Near-duplicate — strengthen existing memory |
+| 75-92% | UPDATE | Related — merge new info into existing |
+| <75% | CREATE | Novel — store as new memory |
+
+**Always prefer `smart_ingest` over `ingest`** — it prevents duplicates and maintains coherence.
+
+### Direct Ingest (When You Need Control)
+
+```
+mcp__vestige__ingest
+  content: "User prefers early returns over nested conditionals"
+  node_type: "preference"
+```
+
+Bypasses dedup logic. Use only when you specifically want to force a new entry.
+
+### Memory (Retrieve/Remove/Check)
+
+```
+mcp__vestige__memory
+  action: "get"
+  id: "{memory-id}"
+```
+
+Actions: `get`, `remove`, `check_state`
+
+## Codebase Tools
+
+```
+mcp__vestige__codebase
+  content: "LoginForm uses composition API with Zod validation"
+  pattern_type: "architecture"
+```
+
+Store codebase patterns and architectural decisions. Pattern types: `architecture`, `pattern`, `convention`, `dependency`.
+
+## Feedback Tools
+
+```
+mcp__vestige__promote_memory id: "{memory-id}"
+mcp__vestige__demote_memory id: "{memory-id}"
+```
+
+Strengthen or weaken memories based on relevance. Use when:
+- **Promote**: Memory proved useful, user referenced it, decision confirmed
+- **Demote**: Memory outdated, user contradicted it, no longer relevant
+
+## Intention Tools
+
+```
+mcp__vestige__intention
+  action: "set"
+  content: "Review test coverage after auth refactor"
+  trigger: "next session"
+```
+
+Actions: `set`, `check`, `complete`, `cancel`
+
+Set reminders and future triggers that surface automatically at session start.
+
+## Session & Maintenance Tools
+
+| Tool | Purpose |
+|------|---------|
+| `session_checkpoint` | Batch-save an entire session's work |
+| `find_duplicates` | Detect and merge redundant memories |
+| `consolidate` | Run FSRS-6 decay and maintenance |
+| `importance_score` | 4-channel scoring (novelty, arousal, reward, attention) |
+| `memory_timeline` | Browse memories chronologically |
+| `health_check` | System health with warnings |
+
+## Proactive Behavior Rules
+
+**These are MUST behaviors, not suggestions:**
+
+### 1. Session Start: Search for Context
+When beginning work on any project, **automatically search** for relevant context:
+```
+mcp__vestige__search query: "{project-name}"
+mcp__vestige__search query: "user-eric"
+mcp__vestige__intention action: "check"
+```
+
+### 2. During Work: Store Decisions As They Happen
+When ANY of these occur, **immediately store without being asked**:
+
+| Event | Action |
+|-------|--------|
+| User states a preference | `smart_ingest` with node_type: "preference" |
+| Architectural decision made | `smart_ingest` with node_type: "decision" |
+| Bug root cause identified | `smart_ingest` with node_type: "bug" |
+| Pattern chosen over alternatives | `smart_ingest` with node_type: "pattern" |
+| User corrects your approach | `smart_ingest` with node_type: "preference" |
+| Codebase pattern discovered | `codebase` with appropriate pattern_type |
+| `/workflows:compound` creates solution | `smart_ingest` with node_type: "pattern" (root cause + insight) |
+| `/workflows:plan` research completes | `smart_ingest` with node_type: "decision" (approach chosen) |
+| `/workflows:review` finds P1/P2 | `smart_ingest` with node_type: "pattern" (finding summary) |
+
+**Recognition patterns** — store when you hear:
+- "I prefer..." / "I like..." / "I always..." / "I never..."
+- "Let's go with X because..." / "We chose X over Y"
+- "The reason this failed was..." / "Root cause:"
+- "From now on..." / "Going forward..."
+- "That's not how we do it" / "Actually, we..."
+
+### 3. Session End: Capture Learnings
+Before ending significant sessions:
+- What decisions were made that should persist?
+- What did you learn about the user's preferences?
+- Set any intentions for future work?
+
+### 4. Before Asking Questions You Might Already Know
+Before asking "What framework do you use?" or "How do you prefer X?", **search first**:
+```
+mcp__vestige__search query: "preference {topic}"
+```
+
+## Node Types Reference
+
+| Type | Use For |
+|------|---------|
+| `preference` | User preferences, corrections, working style |
+| `decision` | Architectural choices with rationale |
+| `pattern` | Reusable code patterns, conventions |
+| `bug` | Root causes worth remembering |
+| `codebase` | Code architecture, file structure, dependencies |
+| `intention` | Future reminders and triggers |
+| `note` | General knowledge, learnings |
+
+## Memory States
+
+Vestige manages memory lifecycle automatically via FSRS-6:
+
+| State | Meaning |
+|-------|---------|
+| **Active** | Readily accessible, frequently retrieved |
+| **Dormant** | Stored but weakly retrievable — promote if still relevant |
+| **Silent** | Deeply encoded, temporarily inaccessible |
+| **Unavailable** | Naturally decayed or removed |
+
+Memories that are searched for get reinforced. Unused memories naturally decay. This prevents knowledge bloat without manual cleanup.
+
+## Decision Logic
+
+**Will it fade if we stop referencing it? That determines where it goes.**
+
+```
+IF knowledge that should strengthen with use, fade if unused
+   (preferences, decisions, patterns, bugs, learnings):
+    → Vestige smart_ingest (neural memory — decays naturally)
+ELSE IF reference material that should never be forgotten
+   (wiki, standards, PRDs, architecture docs, code samples):
+    → Qdrant qdrant-store (permanent library)
+ELSE IF session state or project progress:
+    → Serena write_memory (project workbench)
+ELSE IF future reminder or intention:
+    → Vestige intention
+ELSE IF codebase architecture pattern:
+    → Vestige codebase
+ELSE IF searching for prior context:
+    → Vestige search (semantic + keyword)
+```
+
+## What NOT to Store
+
+- Temporary debugging steps (use Serena session state instead)
+- One-off fixes unlikely to recur
+- Information already in project docs (CLAUDE.md, README)
+- Sensitive data (credentials, API keys)
+- Session progress (use Serena for that)
+
+## Migration from Memory MCP
+
+Vestige replaces Memory MCP. The mapping:
+
+| Memory MCP | Vestige Equivalent |
+|------------|-------------------|
+| `search_nodes` | `search` (semantic + keyword hybrid) |
+| `open_nodes` | `search` with specific name |
+| `create_entities` | `smart_ingest` (auto-dedup) |
+| `add_observations` | `smart_ingest` (auto-UPDATE on similarity) |
+| `create_relations` | Not needed — spreading activation via semantic similarity |
+| `read_graph` | `memory_timeline` or `search` |
+| `delete_*` | `memory` with action: "remove" or `demote_memory` |
+
+## Setup
+
+Install Vestige MCP:
+
+```bash
+# Via cargo (Rust required)
+cargo install vestige-mcp
+
+# Or download binary from releases
+# https://github.com/samvallad33/vestige/releases
+```
+
+Configure in Claude Code:
+```bash
+claude mcp add --scope user vestige -- vestige-mcp
+```
+
+Configuration is stored in `~/.config/vestige/` (global) or `.vestige/` (per-project).