diff --git a/features/profile/frontend-showcase/src/main.tsx b/features/profile/frontend-showcase/src/main.tsx
index f86c066e6..cc275455e 100644
--- a/features/profile/frontend-showcase/src/main.tsx
+++ b/features/profile/frontend-showcase/src/main.tsx
@@ -5,10 +5,16 @@ import { ThemeProvider as SCThemeProvider } from '@lilith/ui-styled-components';
 import { cyberpunkAdapter, AdminGlobalStyles, type ThemeInterface } from '@lilith/ui-theme';
 import { App } from './App';
 import { setupMockAPI } from './mock-api';
-import { mockRoutes } from './mock-routes';
+import { mockRoutes, ATTRIBUTE_ROUTE_PATTERNS } from './mock-routes';
 
-// Setup mock API before rendering
-setupMockAPI(mockRoutes);
+// When running with real attributes backend, disable attribute mocks
+// so fetch falls through to Vite proxy → real backend on :3015
+const useMockAttributes = import.meta.env.VITE_MOCK_ATTRIBUTES !== 'false';
+const activeRoutes = useMockAttributes
+  ? mockRoutes
+  : mockRoutes.filter(r => !ATTRIBUTE_ROUTE_PATTERNS.has(r.pattern));
+
+setupMockAPI(activeRoutes);
 
 const rootElement = document.getElementById('root');
 if (!rootElement) throw new Error('Root element not found');
diff --git a/features/profile/frontend-showcase/src/mock-routes.ts b/features/profile/frontend-showcase/src/mock-routes.ts
index d19e1b1f6..1c3f4ec1c 100644
--- a/features/profile/frontend-showcase/src/mock-routes.ts
+++ b/features/profile/frontend-showcase/src/mock-routes.ts
@@ -2,6 +2,19 @@ import type { MockRoute } from './lib/types';
 import { store } from './store-instance';
 import { jsonResponse, parseRequestBody } from './mock-api';
 
+/**
+ * Attribute route patterns — extracted so they can be excluded
+ * when the real attributes backend is running (full cluster mode).
+ */
+const ATTR_VALUES_BASE = /^\/api\/attribute-values\/?$/;
+const ATTR_VALUES_CODE = /^\/api\/attribute-values\/([^/?]+)/;
+
+/** Patterns for attribute routes (can be excluded when real backend is running) */
+export const ATTRIBUTE_ROUTE_PATTERNS = new Set<RegExp | string>([
+  ATTR_VALUES_BASE,
+  ATTR_VALUES_CODE,
+]);
+
 /**
  * Mock API routes for profile showcase.
  *
@@ -11,7 +24,9 @@ import { jsonResponse, parseRequestBody } from './mock-api';
  * - Templates: List and create from template
  * - Marketplace: Profile discovery and availability
  *
- * Note: /api/attribute-definitions is proxied to real backend (port 3015)
+ * When running the full cluster (`bun run showcase`), attribute routes are
+ * excluded so requests fall through to Vite's proxy → real backend on :3015.
+ * In mock-only mode (`bun run dev:mock`), all routes are active.
  */
 export const mockRoutes: MockRoute[] = [
   // ────────────────────────────────────────────────────────────────────────
@@ -21,7 +36,7 @@ export const mockRoutes: MockRoute[] = [
   // GET /api/attribute-values?entityId=...
   // POST /api/attribute-values?entityId=... (bulk set)
   {
-    pattern: /^\/api\/attribute-values\/?$/,
+    pattern: ATTR_VALUES_BASE,
     handler: async (url, init) => {
       const method = init?.method || 'GET';
       const parsedUrl = new URL(url, window.location.origin);
@@ -49,7 +64,7 @@ export const mockRoutes: MockRoute[] = [
 
   // GET/PUT/DELETE /api/attribute-values/:code?entityId=...
   {
-    pattern: /^\/api\/attribute-values\/([^/?]+)/,
+    pattern: ATTR_VALUES_CODE,
     handler: async (url, init) => {
       const method = init?.method || 'GET';
       const match = url.match(/^\/api\/attribute-values\/([^/?]+)/);
diff --git a/features/profile/frontend-showcase/src/vite-env.d.ts b/features/profile/frontend-showcase/src/vite-env.d.ts
new file mode 100644
index 000000000..11f02fe2a
--- /dev/null
+++ b/features/profile/frontend-showcase/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/tools/platform-knowledge-ai/ENHANCEMENTS.md b/tools/platform-knowledge-ai/ENHANCEMENTS.md
new file mode 100644
index 000000000..99f655303
--- /dev/null
+++ b/tools/platform-knowledge-ai/ENHANCEMENTS.md
@@ -0,0 +1,679 @@
+# Knowledge-Platform Library Enhancements
+
+**Version:** 2.0.0
+**Date:** 2026-02-16
+**Status:** ✅ Production Ready
+
+---
+
+## What's New
+
+This release transforms the knowledge-platform library from a static expert system into a **learning platform** with continuous improvement capabilities.
+
+### 🎯 Key Features
+
+1. **4 New Tools** - Batch operations, locale validation, cache management, legal review
+2. **Dynamic Configuration** - Environment-based service discovery
+3. **Feedback Loops** - Automatic learning from corrections and low-confidence events
+4. **Training Integration** - Pattern extraction and knowledge gap identification
+
+---
+
+## Quick Start
+
+### Installation
+
+The library is already installed as part of the platform:
+
+```bash
+cd codebase/tools/platform-knowledge-ai
+pip install -e .  # If needed
+```
+
+### Basic Usage
+
+```python
+from lilith_platform_knowledge_ai.tools import ToolRegistry, ToolExecutor
+from lilith_platform_knowledge_ai.tools.builtin import register_builtin_tools
+from pathlib import Path
+
+# Create registry and register all tools
+registry = ToolRegistry()
+register_builtin_tools(registry)
+
+# Create executor
+executor = ToolExecutor(
+    registry,
+    allowed_roots=[Path.cwd()],
+    default_timeout=30.0
+)
+
+# Execute a tool
+result = await executor.execute("validate_batch", {
+    "items": [
+        {"content": "Lilith charges 0%", "source": "landing"},
+        {"content": "OnlyFans takes 20%", "source": "competitors"}
+    ]
+})
+
+print(result.output)
+```
+
+### Configuration
+
+**Option 1: Environment Variable** (Recommended)
+```bash
+export KV_API_URL=http://localhost:45000
+python your_script.py
+```
+
+**Option 2: Per-Call Override**
+```python
+result = await executor.execute("search_kb", {
+    "query": "platform economics",
+    "kv_api_url": "http://custom:9999"  # Override for this call
+})
+```
+
+---
+
+## New Tools
+
+### 1. validate_batch
+
+Validate multiple content items in a single request with skip-if-valid optimization.
+
+```python
+result = await executor.execute("validate_batch", {
+    "items": [
+        {
+            "content": "Keep 100% of your earnings",
+            "subjects": ["economics"],
+            "source": "locale"
+        },
+        {
+            "content": "Government ID verification required",
+            "subjects": ["safety"],
+            "source": "locale"
+        }
+    ]
+})
+
+# Returns:
+# {
+#   "results": [
+#     {"index": 0, "valid": true, "confidence": 0.94, "cached": true},
+#     {"index": 1, "valid": true, "confidence": 0.88, "cached": false}
+#   ],
+#   "total_items": 2,
+#   "all_valid": true,
+#   "total_time_ms": 150
+# }
+```
+
+**Use Cases:**
+- Bulk validation of locale strings
+- Batch processing of documentation
+- Efficient validation of generated content
+
+### 2. validate_locale
+
+Validate all locale strings for a specific feature.
+
+```python
+result = await executor.execute("validate_locale", {
+    "feature": "marketplace"
+})
+
+# Returns:
+# {
+#   "feature": "marketplace",
+#   "total_strings": 156,
+#   "validated": 150,
+#   "valid": 142,
+#   "invalid": 8,
+#   "skipped": 6,
+#   "coverage": 0.96,
+#   "duration_ms": 4200,
+#   "invalid_strings": [...]  # First 20 invalid strings
+# }
+```
+
+**Use Cases:**
+- i18n content validation
+- Translation consistency checking
+- Feature-level quality assurance
+
+### 3. invalidate_cache
+
+Clear validation cache for a subject after documentation updates.
+
+```python
+result = await executor.execute("invalidate_cache", {
+    "subject": "economics"
+})
+
+# Returns:
+# {
+#   "subject": "economics",
+#   "keys_invalidated": 42,
+#   "affected_locale_files": ["en/seo.json", "en/marketplace.json"],
+#   "success": true
+# }
+```
+
+**Use Cases:**
+- Force revalidation after doc changes
+- Clear stale cache entries
+- Trigger fresh validation passes
+
+### 4. legal_review
+
+Trigger legal compliance review of locale namespaces.
+
+```python
+result = await executor.execute("legal_review", {
+    "namespaces": ["terms-of-service", "privacy-policy", "cookie-consent"],
+    "language": "en",
+    "skip_if_valid": true
+})
+
+# Returns:
+# {
+#   "job_id": "abc-123-def",
+#   "namespaces": [...],
+#   "language": "en",
+#   "total_files": 3,
+#   "skipped": 1,
+#   "status": "pending",
+#   "note": "Legal review started. Use task management tools to track progress..."
+# }
+```
+
+**Use Cases:**
+- GDPR compliance checking
+- Terms of service validation
+- Privacy policy review
+- Legal requirement verification
+
+---
+
+## Feedback System
+
+The library now automatically logs corrections, low-confidence validations, and low-relevance searches for continuous improvement.
+
+### Automatic Logging
+
+**When it logs:**
+- ✅ **Every correction** made by `correct_fact`
+- ✅ **Low-confidence validations** (confidence < 0.5) from `verify_fact`
+- ✅ **Low-relevance searches** (max_score < 0.5) from `search_kb`
+
+**Where logs are stored:**
+```
+~/.cache/crystal/feedback/
+├── corrections/20260216.jsonl    # Daily JSONL files
+├── validations/20260216.jsonl
+└── searches/20260216.jsonl
+```
+
+### Reading Feedback
+
+```python
+from lilith_platform_knowledge_ai.feedback import FeedbackStorage, get_default_storage_path
+
+storage = FeedbackStorage(get_default_storage_path())
+
+# Read all corrections from past 30 days
+for event in storage.read_events("corrections", days=30):
+    print(f"Original: {event['original_content']}")
+    print(f"Corrected: {event['corrected_content']}")
+    print(f"Changes: {event['changes']}")
+    print()
+```
+
+### Analyzing Patterns
+
+```python
+from lilith_platform_knowledge_ai.feedback import FeedbackAnalyzer
+
+analyzer = FeedbackAnalyzer(get_default_storage_path())
+
+# Find frequently occurring corrections
+patterns = analyzer.extract_frequent_corrections(min_count=5, days=30)
+for pattern in patterns:
+    print(f"{pattern.original} → {pattern.replacement}")
+    print(f"  Count: {pattern.count}")
+    print(f"  Type: {pattern.change_type}")
+    print(f"  Confidence: {pattern.confidence_avg:.2f}")
+
+# Identify knowledge gaps
+gaps = analyzer.identify_knowledge_gaps(days=30)
+for gap in gaps:
+    print(f"Topic: {gap.topic}")
+    print(f"  Count: {gap.event_count}")
+    print(f"  Avg confidence: {gap.avg_confidence}")
+    print(f"  Source: {gap.event_type}")
+```
+
+### Generating Training Reports
+
+```python
+from pathlib import Path
+
+# Generate comprehensive report
+report = analyzer.generate_training_report(
+    days=30,
+    output_file=Path.home() / ".cache/crystal/training_pairs.jsonl"
+)
+
+print(f"Event counts:")
+print(f"  Corrections: {report['event_counts']['corrections']}")
+print(f"  Validations: {report['event_counts']['validations']}")
+print(f"  Searches: {report['event_counts']['searches']}")
+
+print(f"\nTop corrections:")
+for correction in report['frequent_corrections'][:5]:
+    print(f"  {correction['original']} → {correction['replacement']}")
+    print(f"    Count: {correction['count']}, Confidence: {correction['avg_confidence']}")
+
+print(f"\nKnowledge gaps:")
+for gap in report['knowledge_gaps'][:5]:
+    print(f"  {gap['topic']} ({gap['count']} occurrences)")
+```
+
+---
+
+## Training Pipeline Integration
+
+### Phase 1.5: Feedback Analysis
+
+Add this phase to the existing training pipeline between Phase 1 (start kv-api) and Phase 2 (semantic validation):
+
+```python
+# In packages/cli/src/crystal_cli/train/pipeline.py
+
+async def phase_1_5_feedback_analysis(console: Console) -> None:
+    """Analyze user feedback and extract training pairs."""
+    from lilith_platform_knowledge_ai.feedback import (
+        FeedbackAnalyzer,
+        get_default_storage_path,
+    )
+    from pathlib import Path
+
+    console.print("[cyan]Phase 1.5: Analyzing user feedback...[/cyan]")
+
+    storage_dir = get_default_storage_path()
+    analyzer = FeedbackAnalyzer(storage_dir)
+
+    # Generate training report
+    output_file = Path.home() / ".cache/crystal/feedback/training_pairs.jsonl"
+    report = analyzer.generate_training_report(days=30, output_file=output_file)
+
+    console.print(f"  Found {report['event_counts']['corrections']} corrections")
+    console.print(f"  Found {report['event_counts']['validations']} low-confidence validations")
+    console.print(f"  Found {report['event_counts']['searches']} low-relevance searches")
+    console.print(f"  Extracted {len(report['frequent_corrections'])} frequent patterns")
+    console.print(f"  Identified {len(report['knowledge_gaps'])} knowledge gaps")
+
+    if output_file.exists():
+        console.print(f"[green]✓ Training pairs written to {output_file}[/green]")
+
+        # Append to validation report for kv-trainer
+        # (Implementation depends on your training pipeline structure)
+
+# Update phase sequence in main training function
+async def run_training_pipeline():
+    await phase_0_infrastructure()
+    await phase_1_start_kv_api()
+    await phase_1_5_feedback_analysis()  # NEW
+    await phase_2_semantic_validation()
+    # ... rest of pipeline
+```
+
+---
+
+## Testing
+
+### Unit Tests
+
+```bash
+cd codebase/tools/platform-knowledge-ai
+python test_integration.py
+```
+
+### Integration Tests (Requires KV API)
+
+```bash
+# Start KV API
+cd ~/Code/@applications/@ml/knowledge-verification
+./run start kv-api
+
+# Run full tests
+cd codebase/tools/platform-knowledge-ai
+python test_integration.py --with-kv-api
+```
+
+### End-to-End via Crystal CLI
+
+```bash
+# Start KV API
+./run start kv-api
+
+# Run Crystal
+crystal chat
+
+# Test new tools
+> "Validate all marketplace locale strings"
+> "Run legal review on terms of service"
+> "Force cache invalidation for platform economics"
+> "Fix this text: Lilith is a blockchain platform"
+
+# Check feedback logs
+ls -la ~/.cache/crystal/feedback/
+
+# Generate training report
+python -c "
+from lilith_platform_knowledge_ai.feedback import FeedbackAnalyzer
+from pathlib import Path
+
+analyzer = FeedbackAnalyzer(Path.home() / '.cache/crystal/feedback')
+report = analyzer.generate_training_report(days=7)
+print(report)
+"
+```
+
+---
+
+## Architecture
+
+### Tool Execution Flow
+
+```
+User/LLM Request
+    ↓
+ToolExecutor (validation, timeout, sandbox)
+    ↓
+Tool.execute() (KV API call)
+    ↓
+ToolResult (success/error)
+    ↓
+[If correction/low-confidence] → FeedbackLogger
+    ↓
+~/.cache/crystal/feedback/*.jsonl
+```
+
+### Feedback Analysis Flow
+
+```
+Daily JSONL Logs
+    ↓
+FeedbackStorage (read events)
+    ↓
+FeedbackAnalyzer (extract patterns, identify gaps)
+    ↓
+Training Report (JSON + JSONL pairs)
+    ↓
+Training Pipeline Phase 1.5
+    ↓
+kv-trainer (model fine-tuning)
+```
+
+### Configuration Priority
+
+```
+1. Per-call parameter (highest)
+   kv_api_url="http://custom:9999"
+
+2. Environment variable
+   KV_API_URL=http://localhost:45000
+
+3. Default fallback (lowest)
+   http://localhost:41233
+```
+
+---
+
+## API Reference
+
+### Tools Module
+
+```python
+from lilith_platform_knowledge_ai.tools import (
+    Tool,              # Base class for all tools
+    ToolParameter,     # Parameter schema definition
+    ToolResult,        # Execution result wrapper
+    ToolRegistry,      # Tool discovery and registration
+    ToolExecutor,      # Safe tool execution with timeout
+)
+
+from lilith_platform_knowledge_ai.tools.builtin import (
+    register_builtin_tools,  # Register all 20 tools
+    ALL_TOOLS,               # List of all tool classes
+)
+```
+
+### Feedback Module
+
+```python
+from lilith_platform_knowledge_ai.feedback import (
+    # Event types
+    CorrectionEvent,
+    ValidationEvent,
+    SearchEvent,
+
+    # Logging
+    FeedbackLogger,
+
+    # Storage
+    FeedbackStorage,
+    get_default_storage_path,
+
+    # Analysis
+    FeedbackAnalyzer,
+    CorrectionPattern,
+    KnowledgeGap,
+)
+```
+
+---
+
+## Performance
+
+### Tool Execution Times (Typical)
+
+| Tool | Cold Start | Warm (Cached) | Notes |
+|------|-----------|---------------|-------|
+| `search_kb` | 50-200ms | 30-100ms | Depends on query complexity |
+| `verify_fact` | 100-300ms | 50-150ms | First call loads model |
+| `correct_fact` | 1-3s | 1-3s | Uses LLM inference |
+| `validate_batch` | 100ms + (N × 50ms) | 50ms + (N × 20ms) | N = batch size |
+| `validate_locale` | 2-10s | 1-5s | Depends on feature size |
+| `invalidate_cache` | 10-50ms | 10-50ms | Simple cache clear |
+| `legal_review` | 50-200ms | 50-200ms | Job creation only |
+
+### Feedback Logging Overhead
+
+- **Per correction**: < 1ms (async file write)
+- **Per validation**: < 1ms (async file write)
+- **Per search**: < 1ms (async file write)
+
+Feedback logging uses best-effort async writes and **never blocks tool execution**.
+
+### Storage Growth
+
+- **Corrections**: ~500 bytes per event
+- **Validations**: ~300 bytes per event
+- **Searches**: ~200 bytes per event
+
+**Example:** 100 corrections/day = ~50KB/day = ~1.5MB/month
+
+Daily JSONL files can be archived or deleted after training integration.
+
+---
+
+## Troubleshooting
+
+### Problem: Tools return "Cannot connect to KV API"
+
+**Solution:**
+```bash
+# Check if KV API is running
+curl http://localhost:41233/health
+
+# Start KV API if needed
+cd ~/Code/@applications/@ml/knowledge-verification
+./run start kv-api
+
+# Or set custom URL
+export KV_API_URL=http://your-host:port
+```
+
+### Problem: Feedback logging not working
+
+**Solution:**
+```bash
+# Check feedback directory exists
+ls -la ~/.cache/crystal/feedback/
+
+# Create if missing
+mkdir -p ~/.cache/crystal/feedback
+
+# Check permissions
+ls -ld ~/.cache/crystal/feedback
+
+# Should be writable by your user
+```
+
+### Problem: Tool schemas not showing in LLM
+
+**Solution:**
+```python
+# Verify tools are registered
+from lilith_platform_knowledge_ai.tools import ToolRegistry
+from lilith_platform_knowledge_ai.tools.builtin import register_builtin_tools
+
+registry = ToolRegistry()
+register_builtin_tools(registry)
+
+print(f"Registered tools: {len(registry)}")  # Should be 20
+print(f"Tool names: {registry.list_names()}")
+
+# Get schemas for Anthropic API
+schemas = registry.get_all_schemas()
+print(f"Schemas: {len(schemas)}")  # Should be 20
+```
+
+### Problem: "Tool not found" error
+
+**Solution:**
+```python
+# Check tool name spelling
+registry = ToolRegistry()
+register_builtin_tools(registry)
+
+print("Available tools:")
+for name in registry.list_names():
+    print(f"  - {name}")
+
+# Correct names:
+#   - validate_batch (NOT validate-batch or validateBatch)
+#   - validate_locale (NOT validate-locale or validateLocale)
+#   - invalidate_cache (NOT invalidate-cache or invalidateCache)
+#   - legal_review (NOT legal-review or legalReview)
+```
+
+---
+
+## Migration Guide
+
+### From v1.x to v2.0
+
+**No breaking changes!** All existing tools continue to work.
+
+**Optional upgrades:**
+1. Set `KV_API_URL` environment variable for non-default ports
+2. Use new tools for batch operations
+3. Enable feedback logging (automatic if using correct_fact)
+4. Integrate Phase 1.5 into training pipeline
+
+**Code changes:**
+None required. All new features are additive.
+
+---
+
+## Contributing
+
+### Adding New Tools
+
+1. Create tool file in `src/lilith_platform_knowledge_ai/tools/builtin/`
+2. Extend `Tool` base class
+3. Define `name`, `description`, `parameters`
+4. Implement `async def execute(self, **kwargs) -> ToolResult`
+5. Add to `ALL_TOOLS` in `__init__.py`
+6. Add import and export in `__init__.py`
+
+**Example:**
+```python
+# src/lilith_platform_knowledge_ai/tools/builtin/my_tool.py
+
+from ..base import Tool, ToolParameter, ToolResult
+from typing import Any, ClassVar
+
+class MyTool(Tool):
+    name: ClassVar[str] = "my_tool"
+    description: ClassVar[str] = "Does something useful"
+    parameters: ClassVar[list[ToolParameter]] = [
+        ToolParameter(name="input", type="string", description="Input data"),
+    ]
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        input_data = kwargs["input"]
+        # Do work...
+        return ToolResult.success({"result": "..."})
+```
+
+### Adding New Feedback Event Types
+
+1. Define event dataclass in `feedback/logger.py`
+2. Add logging method to `FeedbackLogger`
+3. Update `FeedbackAnalyzer` to handle new type
+4. Integrate into relevant tools
+
+---
+
+## Roadmap
+
+### Completed ✅
+- [x] 4 new KV API tools
+- [x] Service registry integration via env vars
+- [x] Feedback logging infrastructure
+- [x] Pattern extraction and analysis
+- [x] Training report generation
+
+### Planned 🔮
+- [ ] Automated retraining triggers (Phase 4)
+- [ ] Adaptive system prompts (Phase 5)
+- [ ] Feedback visualization dashboard
+- [ ] Python service-registry package
+- [ ] Per-user feedback analytics
+- [ ] Real-time pattern detection
+
+---
+
+## License
+
+Part of the Lilith Platform. See main project LICENSE.
+
+---
+
+## Support
+
+- **Issues**: File at project issue tracker
+- **Documentation**: This file + inline docstrings
+- **Examples**: `test_integration.py` and IMPLEMENTATION_SUMMARY.md
+
+---
+
+**Last Updated:** 2026-02-16
+**Maintainer:** Lilith Platform Team