@nxuss/lemma 1.0.5 → 1.1.1

package/README.md

@@ -1,10 +1,11 @@
-# 🧠 Lemma v1.0.3
+# 🧠 Lemma v1.1.0
 
 [![npm version](https://img.shields.io/npm/v/@nxuss/lemma.svg?color=orange&style=flat-square)](https://www.npmjs.com/package/@nxuss/lemma)
 [![License](https://img.shields.io/npm/l/@nxuss/lemma.svg?color=blue&style=flat-square)](https://github.com/Nxusbets/lemma/blob/main/LICENSE)
-[![MCP Tools](https://img.shields.io/badge/MCP%20tools-51-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
+[![MCP Tools](https://img.shields.io/badge/MCP%20tools-62-ff69b4?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Security](https://img.shields.io/badge/privacy-firewall%20active-blueviolet?style=flat-square)](https://github.com/Nxusbets/lemma)
 [![Caching](https://img.shields.io/badge/semantic%20memory-enabled-success?style=flat-square)](https://github.com/Nxusbets/lemma)
+[![Tests](https://img.shields.io/badge/tests-199%20passing-00c853?style=flat-square)](https://github.com/Nxusbets/lemma)
 
 ```text
     __                                
@@ -16,30 +17,80 @@
 
 > **The Intelligent local-first AI Gateway — Privacy, Performance, and Static Code Intelligence for the Agentic Era.**
 
-Lemma is a high-performance orchestration layer that sits between your development environment and LLM providers. It transforms the way you build with AI by providing **Shared Semantic Memory**, **Autonomous Cost Optimization**, **Privacy Guardrails**, and a suite of **51 MCP tools** — including zero-token static code intelligence that runs entirely on your machine with no LLM calls required.
+Lemma is a high-performance orchestration layer that sits between your development environment and LLM providers. It transforms the way you build with AI by providing **Shared Semantic Memory**, **Autonomous Cost Optimization**, **Privacy Guardrails**, and a suite of **62 MCP tools** — including zero-token static code intelligence that runs entirely on your machine with no LLM calls required.
+
+---
+
+## 📋 Changelog
+
+### v1.1.0 — Token Avalanche *(NEW)*
+
+**11 new tools, all FREE**, focused on maximizing token savings without requiring Pro:
+
+#### 🆓 Free Tools Added in v1.1.0
+
+| Tool | Token Savings | Description |
+| :--- | :--- | :--- |
+| `file_fingerprint` | -60-70% re-reads | SHA256 hash cache per file. Returns 'unchanged' when hash matches, skipping full re-reads. |
+| `git_blame_heat` | -1000-2000 tok/session | Git blame + risk scoring per line. Identifies hotspots and high-risk authors. Zero LLM cost. |
+| `type_coverage_report` | -1000 tok/review | TypeScript type safety score via AST. Reports typed vs untyped declarations, `any` count, score 0-100. |
+| `import_tree_context` | -3000 tok/exploration | Bidirectional import graph. Shows what imports what, external deps, reverse dependencies. |
+| `read_token_budgeted` | -70-90% file reads | Read file with hard token limit. Returns only most relevant sections via AST-based scoring. |
+| `bulk_file_digest` | -80% round-trips | Read N files in one call, return compressed digest. Saves round-trip overhead. |
+| `auto_context_bundle` | -75% round-trips | One-call context: content + imports + schema types + Brain hints. Replaces 4-5 separate tool calls. |
+| `repeat_guard` | -10-15% output | Jaccard similarity check against recent outputs. Prevents duplicate explanations. |
+| `conversation_checkpoint` | -3000-5000 tok/session | Save/load session state to `.lemma/session/`. Prevents re-explaining context across turns. |
+| `test_autofix_interceptor` | -5000 tok/debugging | Run tests + search Brain for matching fixes. Returns failures with suggested fixes from past sessions. |
+| `prompt_pattern_cache` | -20-30% prompts | Find/store optimized prompt templates. Auto-merges similar patterns. Tracks hit counts. |
+
+**Updated TURBOMODE prompt** with 6 new automatic behaviors (rules 4b-4d, 8-12).
+
+#### Other v1.1.0 Changes
+- 199 tests passing (28 new test files)
+- Zero new npm dependencies
+- All new tools are FREE (no Pro license required)
 
 ---
 
 ## 💎 Free vs Pro
 
-| Feature | 🆓 Free | 💎 Pro |
-| :--- | :---: | :---: |
-| **AI Proxy (OpenAI/Anthropic/Gemini)** | ✅ | ✅ |
-| **Exact-match cache** | ✅ | ✅ |
-| **Context Squeezer (auto-compression)** | ✅ | ✅ |
-| **Privacy Firewall (proxy layer)** | ✅ | ✅ |
-| **Complexity Router** | ✅ | ✅ |
-| **Dashboard** | Basic stats | ✅ Full time-travel |
-| **Proxy requests/month** | 300 | ✅ Unlimited |
-| **MCP Server (all 51 tools)** | ❌ | ✅ |
-| **The Brain — Semantic Memory** | ❌ | ✅ |
-| **Zero-Token Static Analysis** | ❌ | ✅ |
-| **Cross-Project Telepathy** | ❌ | ✅ |
-| **AutoPilot & Auto-Heal** | ❌ | ✅ |
-| **`depgraph` — Dependency Graph** | ❌ | ✅ |
-| **`refactor` — Codemod Engine** | ❌ | ✅ |
-
-> **The MCP is Pro.** All 51 tools — The Brain, PreCrime predictor, AST Hologram, Entropy Score, Coupling Radar, `depgraph`, `refactor`, and every optimization tool — require a Pro license. Activate with `lemma activate <key>` → [Get Pro](https://lemma.nxus.studio/upgrade)
+### 🆓 Free (11 Tools)
+
+These tools work **without a Pro license**. Activate them with just `lemma init`:
+
+| Tool | What It Does |
+| :--- | :--- |
+| `file_fingerprint` | File hash cache — avoid re-reads |
+| `git_blame_heat` | Git blame + risk scoring |
+| `type_coverage_report` | TypeScript type safety score |
+| `import_tree_context` | Bidirectional import graph |
+| `read_token_budgeted` | Token-budgeted file reader |
+| `bulk_file_digest` | Multi-file digest in one call |
+| `auto_context_bundle` | Full context bundle per file |
+| `repeat_guard` | Duplicate output detector |
+| `conversation_checkpoint` | Session state save/load |
+| `test_autofix_interceptor` | Test failure → Brain auto-fix |
+| `prompt_pattern_cache` | Reusable prompt templates |
+
+### 💎 Pro (51 Tools)
+
+All remaining tools require a Pro license. Activate with `lemma activate <key>` → [Get Pro](https://lemma.nxus.studio/upgrade)
+
+| Category | Tools |
+| :--- | :--- |
+| **AI Proxy** | OpenAI/Anthropic/Gemini proxy, exact-match cache, context squeezer, complexity router |
+| **Privacy** | Privacy firewall (semantic scrubber), PII masking |
+| **The Brain** | Semantic memory, telepathic hints, hybrid consensus, smarter cache, dedup guard |
+| **Zero-Token Static** | entropy_score, coupling_radar, pattern_fossil, git_heatmap_risk, precrime_static, dead_export_necromancer |
+| **Architecture** | depgraph, refactor, ast_flow_visualizer, imports_skeleton_resolver |
+| **Code Intelligence** | get_ast_hologram, validate_patch_sandbox, surgical_ast_insert, get_symbol_surgical_context |
+| **Workspace** | read/write/create files, apply patches, search, list dirs, run commands |
+| **Optimization** | turbosqueeze, squeeze_prompt, wormhole_squeeze, compress_context, token_budget |
+| **PR Review** | review_diff, review_pr, pr_status, generate_pr_workflow |
+| **Session** | test_oracle, schema_extract, changelog_auto, env_snapshot, migration_tracer |
+| **Automation** | AutoPilot, Auto-Heal, Silent Patch Watcher |
+
+> **The MCP server is Pro.** All 51 Pro tools — The Brain, PreCrime, AST Hologram, `depgraph`, `refactor`, and every optimization tool — require a Pro license. The 11 Free tools listed above are accessible without activation.
 
 ---
 
@@ -63,7 +114,7 @@ Mathematical chaos score (0-100) per file using the TS Compiler API. Measures cy
 ### 🗺️ AST Hologram — Zero Tokens
 Scans the entire workspace and returns a dense JSON index of all exported symbols (classes, functions, interfaces, types, consts) with file paths and line numbers. Use this instead of reading individual files — saves up to 90% tokens when navigating large codebases.
 
-### 📡 `depgraph` — Real-Time Dependency Graph *(NEW in v0.9.3)*
+### 📡 `depgraph` — Real-Time Dependency Graph
 **Architecture-aware blast radius analysis.** Builds a real-time, bidirectional dependency graph for any file in the workspace using the TypeScript Compiler API — zero LLM calls, zero tokens. Shows exactly what a file imports, what imports it (reverse dependencies), and what symbols it exports.
 
 ```
@@ -81,7 +132,7 @@ Scans the entire workspace and returns a dense JSON index of all exported symbol
 
 Supports `--depth` (1-5), `--format text|mermaid|json`, `--reverse`, `--circular` (cycle detection), and `--external` (include node_modules).
 
-### 🔧 `refactor` — Declarative Codemod Engine *(NEW in v0.9.3)*
+### 🔧 `refactor` — Declarative Codemod Engine
 **Multi-file refactoring with surgical precision.** Rename any symbol across the entire workspace or move files updating all importers — using the TypeScript Compiler API for accurate AST-based reference detection. Zero LLM calls.
 
 **`rename`** — Finds every reference to a symbol (via AST, not text search) and renames it everywhere:
@@ -117,70 +168,70 @@ Exposes `write_workspace_file`, smart `apply_workspace_patch` (collision-safe se
 ### 🩺 AutoPilot & Auto-Heal
 Lemma's background file watcher detects TypeScript compilation errors on every save, parses the error, and calls the auto-heal agent to apply a fix — automatically. When Autopilot succeeds, the fix is stored in The Brain for future sessions.
 
-### 🕵️ Silent Patch Watcher *(NEW in v1.0.1)*
+### 🕵️ Silent Patch Watcher
 **Magia negra, no invasiva.** Like Autopilot, but **never touches your code**. Lemma watches your project silently, detects TypeScript errors on save, generates fixes, and stores them as patches in `.lemma/patches/`. You review with `lemma patches` and apply with `lemma apply <id>`.
 
 ```
 lemma watch              ← starts silently watching src/
-[you save a file with a bug]
+[youse save a file with a bug]
 📬 macOS notification    ← "Lemma: TS2322 in route.ts:42"
 lemma patches            ← shows 1 pending fix
 lemma apply ts2322-...   ← applies the fix
 npm run build            ← ✅ passes
 ```
 
-### 🧬 `get_symbol_surgical_context` — Surgical Symbol Context *(NEW in v1.0.0)*
-**Saves up to 90% input tokens.** Instead of reading complete dependency source files, this tool parses your workspace via TS Compiler AST and extracts ONLY the targeted symbol implementation along with the precise function/class signatures of all its direct workspace imports. 
+### 🧬 `get_symbol_surgical_context` — Surgical Symbol Context
+**Saves up to 90% input tokens.** Instead of reading complete dependency source files, this tool parses your workspace via TS Compiler AST and extracts ONLY the targeted symbol implementation along with the precise function/class signatures of all its direct workspace imports.
 
-### ⚙️ `surgical_ast_insert` — AST Surgical Code Injector *(NEW in v1.0.0)*
+### ⚙️ `surgical_ast_insert` — AST Surgical Code Injector
 **Saves up to 95% output tokens.** Removes the need for the LLM to output massive file diffs or rewrite entire files. The LLM only outputs the exact function snippet, and Lemma compiles it surgically into the class/scope AST at the specified anchor point.
 
-### 🩹 `local_semantic_autofix` — Offline Self-Healing *(NEW in v1.0.0)*
+### 🩹 `local_semantic_autofix` — Offline Self-Healing
 **Resolves compilation/runtime crashes in <15ms with 0 tokens.** When your tests or compilers crash, Lemma queries the global error index in `TheBrainV2`. If a matching traceback fix is found in memory (solved in this or any other repo on your machine), it applies the resolution instantly.
 
-### 💰 `generate_executive_roi_report` — Corporate ROI Ledger *(NEW in v1.0.0)*
+### 💰 `generate_executive_roi_report` — Corporate ROI Ledger
 Generates a complete executive Markdown/PDF-ready report of total direct API dollars saved, developer hours reclaimed from caching, security masking events, and scalability financial projections for engineering managers.
 
-### 🌀 `wormhole_squeeze` — Reversible Code Compression *(NEW in v1.0.0)*
+### 🌀 `wormhole_squeeze` — Reversible Code Compression
 Compresses your source code using non-colliding mathematical unicode symbols (like `⨃`, `⨂`, `⨁`) and temporary aliases to shrink file sizes by up to 70% while keeping it 100% reversible.
 
-### 📐 `smart_file_slice` — Context Slicing *(NEW in v1.0.3)*
+### 📐 `smart_file_slice` — Context Slicing
 Reads only the relevant lines of a file around a keyword or query, avoiding sending the entire file to the LLM. Saves ~85% of input tokens.
 
-### 🧪 `test_oracle` — Smart Test Failure Filter *(NEW in v1.0.3)*
+### 🧪 `test_oracle` — Smart Test Failure Filter
 Executes unit tests locally and returns ONLY the failing test cases with compressed stack traces, keeping successful test logs out of the prompt. Saves ~90% tokens.
 
-### 📄 `schema_extract` — High-Level Type Extractor *(NEW in v1.0.3)*
+### 📄 `schema_extract` — High-Level Type Extractor
 Extracts TS interfaces, types, Zod schemas, or Prisma schemas via AST, stripping out all execution and implementation code. Saves ~80% tokens.
 
-### 📜 `changelog_auto` — Zero-Token conventional changelogs *(NEW in v1.0.3)*
+### 📜 `changelog_auto` — Zero-Token conventional changelogs
 Generates a conventional commit changelog directly from git history logs with 0 LLM queries.
 
-### 🪚 `spec_to_stub` — Spec Mock Stub Creator *(NEW in v1.0.3)*
+### 🪚 `spec_to_stub` — Spec Mock Stub Creator
 Parses interfaces and types to output a mock stub template object configuration using pure AST.
 
-### 📋 `env_snapshot` — Env Dependency Capture *(NEW in v1.0.3)*
+### 📋 `env_snapshot` — Env Dependency Capture
 Captures node/npm versions, package.json dependencies, and present `.env` keys (hiding private values/credentials) for instant environment onboarding.
 
-### 🧭 `migration_tracer` — Prisma Migration Analyst *(NEW in v1.0.3)*
+### 🧭 `migration_tracer` — Prisma Migration Analyst
 Traces recent schema modifications (creates, alters, drops) from local Prisma migration files without reading the full SQL code.
 
-### 🩹 `multi_file_patch` — Multi-File Search-and-Replace *(NEW in v1.0.3)* ⭐
+### 🩹 `multi_file_patch` — Multi-File Search-and-Replace
 Applies search-and-replace patches to multiple files in a single call. Eliminates round-trips for multi-file refactoring.
 
-### 📁 `file_intent_index` — Codebase Categorizer *(NEW in v1.0.3)*
+### 📁 `file_intent_index` — Codebase Categorizer
 Automatically groups workspace files by domain intent (auth, routing, config, schemas) for lightning fast navigation.
 
-### 🧠 `cognitive_map` — Auto-Cognitive Knowledge Graph *(NEW in v1.0.3)*
+### 🧠 `cognitive_map` — Auto-Cognitive Knowledge Graph
 A persistent, auto-updating structural knowledge graph representing codebase domains, patterns, decisions, and known bugs at `~/.lemma-cache/cog_map.json`.
 
-### 🔍 `semantic_grep` — BM25 Concept Search *(NEW in v1.0.3)*
+### 🔍 `semantic_grep` — BM25 Concept Search
 Token relevance concept searching across your codebase, allowing natural language queries instead of strict substring matches.
 
-### 📦 `imports_skeleton_resolver` — Import Signature Mapper *(NEW in v1.0.3)*
+### 📦 `imports_skeleton_resolver` — Import Signature Mapper
 Scans imports inside a file and retrieves exported TypeScript signatures from local dependencies in a unified reference sheet. Saves ~85% reading tokens.
 
-### 🎨 `ast_flow_visualizer` — Flowchart Generator *(NEW in v1.0.3)*
+### 🎨 `ast_flow_visualizer` — Flowchart Generator
 Compiles any TS function's control flow statements (loops, ifs, try-catches) into an interactive visual Mermaid diagram rendered directly in markdown.
 
 ---
@@ -212,10 +263,11 @@ lemma start
 | `lemma mcp` | Starts the stdin/stdout MCP server for IDE integration. |
 | `lemma heal` | Auto-diagnose and repair the latest server crash from live context logs. |
 | `lemma autopilot` | Toggle autonomous background watcher mode (auto-applies fixes). |
-| `lemma watch` | **NEW** Silent background watcher — saves patches without touching code. |
-| `lemma patches` | **NEW** List available patches (`--all`, `--pending`). |
-| `lemma apply <id>` | **NEW** Apply a pending fix patch. |
-| `lemma discard <id>` | **NEW** Discard a pending fix patch. |
+| `lemma watch` | Silent background watcher — saves patches without touching code. |
+| `lemma patches` | List available patches (`--all`, `--pending`). |
+| `lemma apply <id>` | Apply a pending fix patch. |
+| `lemma discard <id>` | Discard a pending fix patch. |
+| `lemma activate <key>` | Activate Pro license for full MCP access. |
 
 ### Customizing via `lemma.config.json`
 
@@ -255,11 +307,29 @@ Just run `lemma init`. Lemma automatically registers its MCP server in your `~/.
 }
 ```
 
-Once connected, your IDE gains access to all **38 MCP tools** and Lemma auto-injects the TurboMode system prompt on handshake.
+Once connected, your IDE gains access to **62 MCP tools** — 11 free + 51 Pro. Lemma auto-injects the TurboMode system prompt on handshake.
 
 ---
 
-## 🛠️ MCP Tools Reference (v0.9.3 — 38 Tools)
+## 🛠️ MCP Tools Reference (v1.1.0 — 62 Tools)
+
+### 🆓 Free Tools (11)
+
+> These tools work without a Pro license. All are zero-dependency and run locally.
+
+| Tool | Category | Description |
+| :--- | :--- | :--- |
+| `file_fingerprint` | Smart Read | SHA256 hash cache. Returns 'unchanged' when hash matches, avoiding re-reads. |
+| `git_blame_heat` | Analysis | Git blame + risk scoring per line. Identifies hotspots and high-risk authors. |
+| `type_coverage_report` | Analysis | TypeScript type safety score via AST. Reports typed vs untyped, `any` count. |
+| `import_tree_context` | Architecture | Bidirectional import graph with reverse dependencies. |
+| `read_token_budgeted` | Smart Read | Read file with hard token limit. Returns only relevant sections. |
+| `bulk_file_digest` | Smart Read | Read N files in one call. Returns compressed digest. |
+| `auto_context_bundle` | Smart Read | One-call bundle: content + imports + types + Brain hints. |
+| `repeat_guard` | Optimization | Detects duplicate outputs using Jaccard similarity. |
+| `conversation_checkpoint` | Session | Save/load session state to prevent re-explaining context. |
+| `test_autofix_interceptor` | Automation | Run tests + Brain search for matching fixes. |
+| `prompt_pattern_cache` | Optimization | Find/store optimized prompt templates. |
 
 ### 🗂️ Workspace Tools
 
@@ -267,80 +337,113 @@ Once connected, your IDE gains access to all **38 MCP tools** and Lemma auto-inj
 | :--- | :--- |
 | `read_workspace_file` | Read a file with automatic token compression and privacy scrubbing. |
 | `write_workspace_file` | Write content to a file, creating parent directories as needed. |
-| `apply_workspace_patch` | Smart search-and-replace patch — safe against duplicate matches. Returns clear errors if search block is ambiguous. |
+| `create_workspace_file` | Create a new file (fails if exists). Returns minimal ACK. |
+| `apply_workspace_patch` | Smart search-and-replace patch — safe against duplicate matches. |
+| `multi_file_patch` | Apply patches to multiple files in a single call. |
 | `list_workspace_dir` | Recursively list the project structure up to a configurable depth. |
-| `search_workspace` | Fast text search (grep) across all project files with optional extension filter. Results are privacy-scrubbed. |
-| `run_workspace_command` | Execute bash commands in the workspace root. Secured by an allowlist. 15s timeout. |
+| `search_workspace` | Fast text search (grep) across all project files. |
+| `semantic_grep` | Natural language concept search using BM25. |
+| `run_workspace_command` | Execute bash commands in the workspace root. Secured by allowlist. |
+| `file_intent_index` | Group files by domain intent (auth, routing, config). |
 
 ### 🔬 Code Intelligence Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `get_ast_hologram` | **Holographic AST Map.** Scans the workspace via TS Compiler API and returns a dense JSON index of all exported symbols with file paths and line numbers. Use instead of reading individual files — 90% token savings. Zero LLM calls. |
-| `validate_patch_sandbox` | **Pre-flight Validator.** Validates a proposed patch in an isolated sandbox before applying it. Runs `tsc --noEmit` and bracket-balance checks. Returns `SAFE TO APPLY` or `DO NOT APPLY` verdict. |
-| `diff_only` | Compute a compact line-by-line diff between the last known state of a file and its current content. Session-scoped state tracking. |
+| `get_ast_hologram` | Holographic AST Map of all exported symbols. 90% token savings. |
+| `validate_patch_sandbox` | Pre-flight validator: runs tsc + syntax check before applying. |
+| `diff_only` | Compact line-by-line diff between known states. Session-scoped. |
+| `surgical_ast_insert` | Insert code at AST anchor point. 95% output token savings. |
+| `get_symbol_surgical_context` | Extract symbol + dependency signatures only. 90% savings. |
+| `smart_file_slice` | Read only relevant lines around a query. 85% savings. |
+| `schema_extract` | Extract interfaces/types/schemas via AST. 80% savings. |
+| `spec_to_stub` | Generate mock stubs from TypeScript interfaces. |
+| `ast_flow_visualizer` | Mermaid flowchart from function control flow. |
+| `imports_skeleton_resolver` | Import signature mapper for quick reference. |
 
 ### 🧠 Brain & Memory Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `search_memory` | Semantic search across The Brain — retrieves past solutions and context from all your projects globally. |
-| `store_memory` | Persist a technical solution, bug fix, or architecture decision into The Brain for future sessions. |
-| `query_hybrid_consensus` | **Hybrid Consensus Engine.** Checks The Brain at configurable threshold (default 80%). HIT → instant answer, zero cloud tokens. MISS → proceed with cloud and cache afterward. |
-| `get_telepathic_hints` | **Proactive Telepathy.** Given the active file path, surfaces the top N most relevant past solutions from The Brain — no query needed. |
+| `search_memory` | Semantic search across The Brain from all projects globally. |
+| `store_memory` | Persist solutions, fixes, decisions into The Brain. |
+| `query_hybrid_consensus` | Hybrid cache: 80% threshold → instant answer, 0 cloud tokens. |
+| `get_telepathic_hints` | Proactive hints from The Brain based on active file. |
+| `smarter_cache` | Predictive cache at 75% threshold before any reasoning. |
+| `semantic_dedup_guard` | Brain dedup firewall. Rejects ≥92% similar entries. |
+| `local_semantic_autofix` | Offline self-healing from Brain error index. |
 
 ### ⚙️ Optimization & Privacy Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `scrub_privacy` | Mask PII, API keys, and secrets from any text block using the Privacy Firewall. |
-| `squeeze_prompt` | Compress code blocks and boilerplate in any prompt. Up to 80% token reduction. |
-| `turbosqueeze` | **Extreme compression.** Strips comments, imports, whitespace, and compacts JSON. Returns reduction stats. |
-| `compress_context` | Summarizes old conversation turns, keeps last N turns intact. Falls back to truncation if no Ollama. |
-| `prune_conversation_history` | Intelligently decimate conversation history while preserving critical recent context. |
-| `summarize_long_text` | Summarize lengthy content via Ollama to save context window space. Falls back gracefully. |
-| `smarter_cache` | **Predictive cache.** Queries The Brain at 75% threshold before any reasoning. Auto-suggests `store_memory` on MISS. |
-| `token_budget` | Optimization dashboard: multiplier, total tokens saved, active strategies, and recommendations. |
-| `get_routing_advice` | Analyze a prompt and get optimal model recommendation from the Complexity Router. |
-| `get_project_onboarding` | Download a one-shot architectural mental model of the current codebase. |
-| `auto_heal` | Diagnose and auto-heal the latest crash from Lemma's live context logs. |
-| `batch_tool_calls` | Execute multiple tool calls in parallel via `Promise.all`. High-throughput operations in a single MCP round-trip. |
+| `scrub_privacy` | Mask PII, API keys, secrets from any text block. |
+| `squeeze_prompt` | Compress code blocks. Up to 80% token reduction. |
+| `turbosqueeze` | Extreme compression: strips comments, imports, whitespace. |
+| `wormhole_squeeze` | Reversible unicode compression. 60-70% reduction. |
+| `compress_context` | Summarize old conversation turns. Keeps last N intact. |
+| `prune_conversation_history` | Intelligently decimate history preserving critical context. |
+| `summarize_long_text` | Summarize via Ollama. Falls back to truncation. |
+| `token_budget` | Dashboard: multiplier, savings, strategies, recommendations. |
+| `get_routing_advice` | Optimal model recommendation from Complexity Router. |
+| `get_project_onboarding` | One-shot architectural mental model. |
+| `auto_heal` | Auto-diagnose and repair crashes from live context. |
+| `batch_tool_calls` | Execute multiple tools in parallel via Promise.all. |
 
 ### 🔮 Zero-Token Static Intelligence Tools
 
-> All tools in this section use **zero LLM tokens, zero Ollama, zero cloud**. Pure local computation via TypeScript Compiler API, git, and math.
+> All tools in this section use **zero LLM tokens**. Pure local computation.
+
+| Tool | Description |
+| :--- | :--- |
+| `entropy_score` | Mathematical chaos score (0-100) per file. |
+| `coupling_radar` | Dependency graph: circular imports, god modules, dead islands. |
+| `pattern_fossil` | Zombie code detector: var vs const, callbacks vs async/await. |
+| `git_heatmap_risk` | Git churn analysis + co-edit pairs. |
+| `precrime_static` | Composite risk predictor combining entropy + coupling + git. |
+| `dead_export_necromancer` | Dead code auditor: exported but never imported. |
+| `git_blame_heat` | Git blame + per-line risk scoring. |
+| `type_coverage_report` | TypeScript type safety score. |
+| `import_tree_context` | Bidirectional import graph. |
+
+### 🏗️ Architecture & Refactoring Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `entropy_score` | **Mathematical chaos score** (0-100) per file. Measures cyclomatic complexity, max nesting depth, `any` type ratio, and average function size. Identifies which files need refactoring before you touch them. |
-| `coupling_radar` | **Dependency graph analysis.** Detects circular imports, god modules (high fan-in), dead islands (no importers), and fan-in/fan-out per module. Essential before large refactors. |
-| `pattern_fossil` | **Zombie code detector.** Finds patterns that were replaced in most of the codebase but survive in old files: `var` vs `const/let`, callbacks vs `async/await`, `require()` vs `import`, `: any` vs generics. Reports adoption percentage. |
-| `git_heatmap_risk` | **Git churn analysis.** Calculates change frequency per file and co-edit pairs (files that always change together = hidden coupling). Returns a risk score for each file based on historical git behavior. |
-| `precrime_static` | **Minority Report predictor.** Combines `entropy_score` (40%) + `git_heatmap_risk` (40%) + `coupling_radar` (20%) into a composite PreCrime Score per file. Ranks files by bug probability with per-factor breakdown and names the riskiest functions. |
-| `semantic_dedup_guard` | **Brain dedup firewall.** Before calling `store_memory`, pass content through here. If similarity ≥ 92% → rejects as duplicate. If 75–91% → warns and shows the similar entry. Keeps The Brain lean and dense. |
-| `dead_export_necromancer` | **Dead code auditor.** Maps every `export` in the workspace against every `import`. Symbols exported but never imported anywhere = zombie code inflating your context. Reports dead exports by file with estimated token waste. |
+| `depgraph` | Real-time dependency graph with depth, format, circular detection. |
+| `refactor` | Declarative codemod: rename symbols or move files. |
+| `cognitive_map` | Auto-updating knowledge graph of domains and patterns. |
+
+### 🔍 PR Review Agent Tools
 
-### 🏗️ Architecture & Refactoring Tools *(NEW in v0.9.3)*
+| Tool | Description |
+| :--- | :--- |
+| `review_diff` | Analyze raw diff for bugs, security, best practices. |
+| `review_pr` | Full PR review against GitHub, Azure DevOps, GitLab. |
+| `pr_status` | Query last review status for a PR. |
+| `generate_pr_workflow` | Generate CI/CD workflow YAML for PR reviews. |
 
-> Architecture-aware tools that combine dependency analysis with surgical code transformation. **Zero LLM calls.**
+### 🧪 Testing & Quality Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `depgraph` | **Real-time dependency graph.** Builds a bidirectional import/export map for any file. Shows what a file imports, what imports it (reverse deps with `--reverse`), and what symbols it exports. Supports `--depth` 1-5, `--format text\|mermaid\|json`, `--circular` (cycle detection), and `--external` (include node_modules). Use before any refactor to measure blast radius. |
-| `refactor` | **Declarative codemod engine.** `rename` renames a symbol across all files using AST-based reference detection (no false positives from string search). `move` relocates a file and rewires every import path in the workspace. Both support `--dryRun` (unified diff preview), `--tscCheck` (post-apply type verification), and `--backup` (`.bak` files). |
+| `test_oracle` | Run tests, return only failures with compressed traces. |
+| `test_autofix_interceptor` | Run tests + Brain search for matching fixes. |
+| `changelog_auto` | Conventional commit changelog from git history. |
+| `env_snapshot` | Node/npm versions, deps, .env keys (values hidden). |
+| `migration_tracer` | Prisma migration schema diff analysis. |
 
-### 🔍 PR Review Agent Tools
+### 📋 Session & Automation Tools
 
 | Tool | Description |
 | :--- | :--- |
-| `review_diff` | Analyze a raw diff for bugs, security issues, and best practices before committing. |
-| `review_pr` | Full PR review against a Git platform (GitHub, Azure DevOps, GitLab). Runs all 4 analyzers (Static, Security, Regression, Quality) and stores results in The Brain. |
-| `pr_status` | Query the last review status and report for a given PR number and platform. |
-| `generate_pr_workflow` | Generate a CI/CD workflow YAML (GitHub Actions or Azure Pipelines) that runs `lemma pr-review` as a step. |
+| `conversation_checkpoint` | Save/load session state to `.lemma/session/`. |
+| `prompt_pattern_cache` | Find/store optimized prompt templates. |
+| `review_pr` | Full PR review with auto-approve option. |
 
 ### ⚡ TurboMode Auto-Injection
 
-When connected via `lemma mcp`, Lemma auto-injects 7 rules into the agent's system prompt on handshake:
+When connected via `lemma mcp`, Lemma auto-injects 12 rules into the agent's system prompt on handshake:
 
 1. `turbosqueeze` before writing large code blocks
 2. `smarter_cache` before any reasoning
@@ -349,6 +452,11 @@ When connected via `lemma mcp`, Lemma auto-injects 7 rules into the agent's syst
 5. `batch_tool_calls` for parallel operations
 6. `semantic_dedup_guard` before every `store_memory`
 7. No fluff, no chit-chat — maximum density
+8. `auto_context_bundle` or `bulk_file_digest` for multi-file ops
+9. `repeat_guard` before long outputs
+10. `conversation_checkpoint` to restore session context
+11. `test_autofix_interceptor` when tests fail
+12. `prompt_pattern_cache` for repetitive prompts
 
 ---
 
@@ -356,11 +464,11 @@ When connected via `lemma mcp`, Lemma auto-injects 7 rules into the agent's syst
 
 | Resource URI | Description |
 | :--- | :--- |
-| `lemma://runtime/context` | Live application errors, stack traces, and runtime state. Subscribable — IDE notified instantly on crash. |
-| `lemma://stats/usage` | Current token savings, cost report, and cache hit metrics in JSON. |
-| `lemma://project/context` | Active project metadata, tech stack, memory count, and token savings. |
-| `lemma://project/onboarding` | Dynamic project architecture guide compiled on demand. |
-| `lemma://multiverse/timeline` | Chronological AST diff timeline of recent code snapshots. |
+| `lemma://runtime/context` | Live application errors, stack traces, and runtime state. |
+| `lemma://stats/usage` | Current token savings, cost report, and cache hit metrics. |
+| `lemma://project/context` | Active project metadata, tech stack, memory count. |
+| `lemma://project/onboarding` | Dynamic project architecture guide. |
+| `lemma://multiverse/timeline` | Chronological AST diff timeline of recent snapshots. |
 
 ---
 

package/dist/cjs/mcp/prompts.d.ts

@@ -1,5 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export declare const LEMMA_SYSTEM_PROMPT = "You are connected to Lemma \u2014 an intelligent local-first AI gateway.\nLemma gives you a set of tools you MUST use proactively and automatically. NEVER ask the user\nto call a tool manually. YOU invoke the tools. The user should experience zero friction.\n\n## MANDATORY AUTOMATIC BEHAVIORS\n\n### 1. Before reading ANY file \u2192 call get_ast_hologram first\nWhen you need to understand the structure of a codebase or navigate files, ALWAYS call\n`get_ast_hologram` first (with the relevant dirPath, e.g. \"src\"). Use the returned symbol\nmap to pinpoint exactly which files to read. NEVER blindly read every file one by one.\n\n### 2. Before answering ANY technical question \u2192 call query_hybrid_consensus first\nBEFORE making any reasoning or cloud LLM call, ALWAYS call `query_hybrid_consensus` with\nthe user's question. If similarity \u2265 80%, return the cached answer immediately \u2014 no cloud\ncall needed. Only proceed with your own reasoning if the Brain returns a MISS.\n\n### 3. When you start working on ANY file \u2192 call get_telepathic_hints automatically\nWhenever the user mentions a file or you are about to read/edit a file, IMMEDIATELY call\n`get_telepathic_hints` with that file's path. Surface the results to the user as relevant\ncontext BEFORE doing any work. Do not ask permission \u2014 just do it.\n\n### 4. Before applying ANY code patch \u2192 call validate_patch_sandbox first\nNEVER call `write_workspace_file` or `apply_workspace_patch` without FIRST calling\n`validate_patch_sandbox` with the proposed content. Only proceed with the write if the\nverdict is \"\u2705 SAFE TO APPLY\". If it fails, fix the issues and re-validate.\n\n### 5. After solving any technical problem \u2192 call store_memory automatically\nAfter resolving a bug, implementing a feature, or answering a significant technical question,\nALWAYS call `store_memory` to persist the solution. Use a descriptive query key so it can\nbe retrieved in future sessions across ALL projects.\n\n### 6. Workspace navigation \u2192 always use Lemma tools, NEVER guess file contents\n- Use `list_workspace_dir` to navigate structure\n- Use `read_workspace_file` (auto-compresses + scrubs secrets) instead of asking the user\n- Use `search_workspace` for text search across files\n- Use `run_workspace_command` for builds, tests, linters\n\n### 7. Privacy is automatic\n`read_workspace_file` and `search_workspace` automatically scrub API keys and PII.\nYou never need to manually sanitize file content.\n\n## LEMMA RESOURCES (auto-subscribe when available)\n- `lemma://runtime/context` \u2014 live crash logs. Read this FIRST when the user reports a bug.\n- `lemma://multiverse/timeline` \u2014 AST history. Use when the user says \"it was working before\".\n- `lemma://project/onboarding` \u2014 architecture map. Read at session start in new repos.\n- `lemma://stats/usage` \u2014 token savings report.\n\nRemember: the user hired YOU to be autonomous. Act like it.";
-export declare const LEMMA_TURBOMODE_PROMPT = "You are operating in LEMMA TURBOMODE. Your goal: multiply the user's LLM membership 50x by spending 50x fewer tokens per task. Every token counts. Every cache hit is a membership extension.\n\n## MANDATORY TURBOMODE RULES \u2014 VIOLATE THESE AND YOU WASTE THE USER'S MONEY\n\n### 0. Before ANYTHING \u2192 check token_budget\nEvery 5 turns, call `token_budget` to check your consumption. If multiplier drops below 10x, optimize harder.\n\n### 1. Before sending ANY code \u2192 call turbosqueeze\nBEFORE including ANY code block in your response, run it through `turbosqueeze` first. Strip comments, collapse whitespace, remove imports. A 500-line file becomes 50 lines. This is your #1 token saver.\n\n### 2. Before reasoning \u2192 call smarter_cache (threshold 0.75)\nNEVER reason from scratch. Call `smarter_cache` with the user's exact question. If similarity >= 75%, return the cached answer INSTANTLY. Zero cloud tokens spent. Only reason if you get a MISS.\n\n### 3. Before every new turn \u2192 call compress_context\nAt the start of any extended interaction, call `compress_context` on the full message history. Keep only the last 3 turns intact. Summarize everything before that into 2 sentences. This keeps your context window lean.\n\n### 4. Before reading files \u2192 call get_ast_hologram\nNEVER read files blindly. Always call `get_ast_hologram` first to locate the exact symbols you need. Then read only those specific files. Each unnecessary file read wastes 1000+ tokens.\n\n### 5. After every solution \u2192 call store_memory automatically\nEvery bug fix, feature, or answer MUST be stored via `store_memory`. This creates a permanent cache hit for future sessions. The first time costs tokens; every time after is FREE.\n\n### 6. Answer concisely \u2014 no fluff\n- No \"Sure, I can help you with that\" \u2014 just do it.\n- No explanation of what you did \u2014 unless asked.\n- No markdown formatting in internal responses.\n- No repeating the user's question back to them.\n\n### 7. Use batch_tool_calls aggressively\nAny set of independent operations (read 3 files, search 2 patterns, check cache for 2 questions) \u2014 use `batch_tool_calls` to run them in parallel. Single round-trip > multiple sequential calls.\n\n## TURBOMODE SCORING\n- Cache HIT = perfect score (0 tokens spent)\n- Cache MISS + compress = good score (< 100 tokens spent on overhead)\n- Reasoning from scratch = bad score (only when absolutely necessary)\n- Reading full files without hologram = FAIL (wasteful)\n\nRemember: this user has a deadline. Every token you save is time and money. Make every token count.";
+export declare const LEMMA_TURBOMODE_PROMPT = "You are operating in LEMMA TURBOMODE. Your goal: multiply the user's LLM membership 50x by spending 50x fewer tokens per task. Every token counts. Every cache hit is a membership extension.\n\n## MANDATORY TURBOMODE RULES \u2014 VIOLATE THESE AND YOU WASTE THE USER'S MONEY\n\n### 0. Before ANYTHING \u2192 check token_budget\nEvery 5 turns, call `token_budget` to check your consumption. If multiplier drops below 10x, optimize harder.\n\n### 1. Before sending ANY code \u2192 call turbosqueeze\nBEFORE including ANY code block in your response, run it through `turbosqueeze` first. Strip comments, collapse whitespace, remove imports. A 500-line file becomes 50 lines. This is your #1 token saver.\n\n### 2. Before reasoning \u2192 call smarter_cache (threshold 0.75)\nNEVER reason from scratch. Call `smarter_cache` with the user's exact question. If similarity >= 75%, return the cached answer INSTANTLY. Zero cloud tokens spent. Only reason if you get a MISS.\n\n### 3. Before every new turn \u2192 call compress_context\nAt the start of any extended interaction, call `compress_context` on the full message history. Keep only the last 3 turns intact. Summarize everything before that into 2 sentences. This keeps your context window lean.\n\n### 4. Before reading files \u2192 call get_ast_hologram\nNEVER read files blindly. Always call `get_ast_hologram` first to locate the exact symbols you need. Then read only those specific files. Each unnecessary file read wastes 1000+ tokens.\n\n### 4b. Before re-reading a file \u2192 call file_fingerprint\nBefore calling read_workspace_file, check if the file hash has changed since last read. If status is 'unchanged', skip the read entirely. Only read when hash differs.\n\n### 4c. Before deep file analysis \u2192 use import_tree_context + type_coverage_report\nInstead of reading full files to understand architecture, call import_tree_context (import graph) and type_coverage_report (type safety). Both are zero-token tools.\n\n### 4d. Before investigating code ownership \u2192 call git_blame_heat\nFor questions about who wrote code, why it's risky, or change history, call git_blame_heat instead of reasoning. Zero LLM cost.\n\n### 5. After every solution \u2192 call store_memory automatically\nEvery bug fix, feature, or answer MUST be stored via `store_memory`. This creates a permanent cache hit for future sessions. The first time costs tokens; every time after is FREE.\n\n### 6. Answer concisely \u2014 no fluff\n- No \"Sure, I can help you with that\" \u2014 just do it.\n- No explanation of what you did \u2014 unless asked.\n- No markdown formatting in internal responses.\n- No repeating the user's question back to them.\n\n### 7. Use batch_tool_calls aggressively\nAny set of independent operations (read 3 files, search 2 patterns, check cache for 2 questions) \u2014 use `batch_tool_calls` to run them in parallel. Single round-trip > multiple sequential calls.\n\n### 8. Before multi-file operations \u2192 use auto_context_bundle or bulk_file_digest\nInstead of reading files one by one, use `auto_context_bundle` (one file, everything included) or `bulk_file_digest` (multiple files, one call). Both save 75-80% round-trips.\n\n### 9. Before outputting long responses \u2192 check repeat_guard\nCall `repeat_guard` with your draft output to avoid repeating yourself. Saves 10-15% of output tokens.\n\n### 10. When resuming work \u2192 load conversation_checkpoint\nAt session start or when user says \"continuemos\", call `conversation_checkpoint` with action \"load\" to restore context without re-explaining.\n\n### 11. When tests fail \u2192 use test_autofix_interceptor\nInstead of manually reading errors and reasoning, call `test_autofix_interceptor` to get failures + Brain-suggested fixes in one call.\n\n### 12. For common prompt patterns \u2192 use prompt_pattern_cache\nBefore generating repetitive prompts (\"explain this\", \"review this\", \"write tests\"), check `prompt_pattern_cache` action \"find\" for cached templates.\n\n## TURBOMODE SCORING\n- Cache HIT = perfect score (0 tokens spent)\n- Cache MISS + compress = good score (< 100 tokens spent on overhead)\n- Reasoning from scratch = bad score (only when absolutely necessary)\n- Reading full files without hologram = FAIL (wasteful)\n\nRemember: this user has a deadline. Every token you save is time and money. Make every token count.";
 export declare function setupPromptsHandlers(server: Server): void;
 //# sourceMappingURL=prompts.d.ts.map

package/dist/cjs/mcp/prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/mcp/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAGnE,eAAO,MAAM,mBAAmB,m6FA+C4B,CAAC;AAE7D,eAAO,MAAM,sBAAsB,4jFAqCiE,CAAC;AAErG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiDzD"}
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../src/mcp/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAGnE,eAAO,MAAM,mBAAmB,m6FA+C4B,CAAC;AAE7D,eAAO,MAAM,sBAAsB,yyIA6DiE,CAAC;AAErG,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiDzD"}

package/dist/cjs/mcp/prompts.js

@@ -70,6 +70,15 @@ At the start of any extended interaction, call \`compress_context\` on the full
 ### 4. Before reading files → call get_ast_hologram
 NEVER read files blindly. Always call \`get_ast_hologram\` first to locate the exact symbols you need. Then read only those specific files. Each unnecessary file read wastes 1000+ tokens.
 
+### 4b. Before re-reading a file → call file_fingerprint
+Before calling read_workspace_file, check if the file hash has changed since last read. If status is 'unchanged', skip the read entirely. Only read when hash differs.
+
+### 4c. Before deep file analysis → use import_tree_context + type_coverage_report
+Instead of reading full files to understand architecture, call import_tree_context (import graph) and type_coverage_report (type safety). Both are zero-token tools.
+
+### 4d. Before investigating code ownership → call git_blame_heat
+For questions about who wrote code, why it's risky, or change history, call git_blame_heat instead of reasoning. Zero LLM cost.
+
 ### 5. After every solution → call store_memory automatically
 Every bug fix, feature, or answer MUST be stored via \`store_memory\`. This creates a permanent cache hit for future sessions. The first time costs tokens; every time after is FREE.
 
@@ -82,6 +91,21 @@ Every bug fix, feature, or answer MUST be stored via \`store_memory\`. This crea
 ### 7. Use batch_tool_calls aggressively
 Any set of independent operations (read 3 files, search 2 patterns, check cache for 2 questions) — use \`batch_tool_calls\` to run them in parallel. Single round-trip > multiple sequential calls.
 
+### 8. Before multi-file operations → use auto_context_bundle or bulk_file_digest
+Instead of reading files one by one, use \`auto_context_bundle\` (one file, everything included) or \`bulk_file_digest\` (multiple files, one call). Both save 75-80% round-trips.
+
+### 9. Before outputting long responses → check repeat_guard
+Call \`repeat_guard\` with your draft output to avoid repeating yourself. Saves 10-15% of output tokens.
+
+### 10. When resuming work → load conversation_checkpoint
+At session start or when user says "continuemos", call \`conversation_checkpoint\` with action "load" to restore context without re-explaining.
+
+### 11. When tests fail → use test_autofix_interceptor
+Instead of manually reading errors and reasoning, call \`test_autofix_interceptor\` to get failures + Brain-suggested fixes in one call.
+
+### 12. For common prompt patterns → use prompt_pattern_cache
+Before generating repetitive prompts ("explain this", "review this", "write tests"), check \`prompt_pattern_cache\` action "find" for cached templates.
+
 ## TURBOMODE SCORING
 - Cache HIT = perfect score (0 tokens spent)
 - Cache MISS + compress = good score (< 100 tokens spent on overhead)

package/dist/cjs/mcp/prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/mcp/prompts.ts"],"names":[],"mappings":";;;AA2FA,oDAiDC;AA3ID,iEAAsG;AAEzF,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DA+CyB,CAAC;AAEhD,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAqC8D,CAAC;AAErG,SAAgB,oBAAoB,CAAC,MAAc;IACjD,MAAM,CAAC,iBAAiB,CAAC,mCAAwB,EAAE,KAAK,IAAI,EAAE;QAC5D,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,iBAAiB;oBACvB,WAAW,EAAE,+JAA+J;oBAC5K,SAAS,EAAE,EAAE;iBACd;gBACD;oBACE,IAAI,EAAE,iBAAiB;oBACvB,WAAW,EAAE,wOAAwO;oBACrP,SAAS,EAAE,EAAE;iBACd;aACF;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,iBAAiB,CAAC,iCAAsB,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QACjE,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC9C,OAAO;gBACL,WAAW,EAAE,qCAAqC;gBAClD,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE;4BACP,IAAI,EAAE,MAAM;4BACZ,IAAI,EAAE,2BAAmB;yBAC1B;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC9C,OAAO;gBACL,WAAW,EAAE,8CAA8C;gBAC3D,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE;4BACP,IAAI,EAAE,MAAM;4BACZ,IAAI,EAAE,8BAAsB;yBAC7B;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,mBAAmB,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/mcp/prompts.ts"],"names":[],"mappings":";;;AAmHA,oDAiDC;AAnKD,iEAAsG;AAEzF,QAAA,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DA+CyB,CAAC;AAEhD,QAAA,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oGA6D8D,CAAC;AAErG,SAAgB,oBAAoB,CAAC,MAAc;IACjD,MAAM,CAAC,iBAAiB,CAAC,mCAAwB,EAAE,KAAK,IAAI,EAAE;QAC5D,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,iBAAiB;oBACvB,WAAW,EAAE,+JAA+J;oBAC5K,SAAS,EAAE,EAAE;iBACd;gBACD;oBACE,IAAI,EAAE,iBAAiB;oBACvB,WAAW,EAAE,wOAAwO;oBACrP,SAAS,EAAE,EAAE;iBACd;aACF;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,iBAAiB,CAAC,iCAAsB,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QACjE,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC9C,OAAO;gBACL,WAAW,EAAE,qCAAqC;gBAClD,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE;4BACP,IAAI,EAAE,MAAM;4BACZ,IAAI,EAAE,2BAAmB;yBAC1B;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC9C,OAAO;gBACL,WAAW,EAAE,8CAA8C;gBAC3D,QAAQ,EAAE;oBACR;wBACE,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE;4BACP,IAAI,EAAE,MAAM;4BACZ,IAAI,EAAE,8BAAsB;yBAC7B;qBACF;iBACF;aACF,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,mBAAmB,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/cjs/mcp/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AA41BnE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,MAAM,EAAE,IAAI,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAC1C,IAAI,CA2DN"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/mcp/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAkgCnE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,MAAM,EAAE,IAAI,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAC1C,IAAI,CA2DN"}