fix: add comprehensive addNode examples to n8n_update_partial_workflow documentation

Fixes #269

## Problem
Claude didn't know how to use the addNode operation because the MCP tool
documentation lacked working examples. Users were getting errors like:
- "Cannot read properties of undefined (reading 'name')"
- "Unknown operation type: n8n-nodes-base.set"

## Root Cause
The tool documentation mentioned addNode as one of 6 node operations but
had ZERO examples showing the correct syntax. All 6 examples focused on
v2.14.4 cleanup features, leaving out the most commonly used operation.

## Solution
Added 4 comprehensive examples showing addNode usage patterns:
1. Basic addNode with minimal configuration
2. Complete addNode with full parameters
3. addNode + addConnection combo (most common pattern)
4. Batch operation with multiple nodes

Examples array increased from 6 to 10 total examples, with 40% now
dedicated to addNode operations.

## Correct Syntax Demonstrated
```typescript
{
  type: 'addNode',
  node: {
    name: 'Node Name',
    type: 'n8n-nodes-base.xxx',
    position: [x, y],
    parameters: { ... }
  }
}
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -132,4 +132,36 @@ ENABLE_MULTI_TENANT=false
 
 # Enable metadata generation during template fetch (default: false)
 # Set to true to automatically generate metadata when running fetch:templates
-# METADATA_GENERATION_ENABLED=false
+# METADATA_GENERATION_ENABLED=false
+
+# ========================================
+# INTEGRATION TESTING CONFIGURATION
+# ========================================
+# Configuration for integration tests that call real n8n instance API
+
+# n8n API Configuration for Integration Tests
+# For local development: Use your local n8n instance
+# For CI: These will be provided by GitHub secrets
+# N8N_API_URL=http://localhost:5678
+# N8N_API_KEY=
+
+# Pre-activated Webhook Workflows for Testing
+# These workflows must be created manually in n8n and activated
+# because n8n API doesn't support workflow activation.
+#
+# Setup Instructions:
+# 1. Create 4 workflows in n8n UI (one for each HTTP method)
+# 2. Each workflow should have a single Webhook node
+# 3. Configure webhook paths: mcp-test-get, mcp-test-post, mcp-test-put, mcp-test-delete
+# 4. ACTIVATE each workflow in n8n UI
+# 5. Copy the workflow IDs here
+#
+# N8N_TEST_WEBHOOK_GET_ID=      # Workflow ID for GET method webhook
+# N8N_TEST_WEBHOOK_POST_ID=     # Workflow ID for POST method webhook
+# N8N_TEST_WEBHOOK_PUT_ID=      # Workflow ID for PUT method webhook
+# N8N_TEST_WEBHOOK_DELETE_ID=   # Workflow ID for DELETE method webhook
+
+# Test Configuration
+N8N_TEST_CLEANUP_ENABLED=true         # Enable automatic cleanup of test workflows
+N8N_TEST_TAG=mcp-integration-test     # Tag applied to all test workflows
+N8N_TEST_NAME_PREFIX=[MCP-TEST]       # Name prefix for test workflows

.github/workflows/test.yml

@@ -72,6 +72,12 @@ jobs:
         run: npm run test:integration -- --reporter=default --reporter=junit
         env:
           CI: true
+          N8N_API_URL: ${{ secrets.N8N_API_URL }}
+          N8N_API_KEY: ${{ secrets.N8N_API_KEY }}
+          N8N_TEST_WEBHOOK_GET_URL: ${{ secrets.N8N_TEST_WEBHOOK_GET_URL }}
+          N8N_TEST_WEBHOOK_POST_URL: ${{ secrets.N8N_TEST_WEBHOOK_POST_URL }}
+          N8N_TEST_WEBHOOK_PUT_URL: ${{ secrets.N8N_TEST_WEBHOOK_PUT_URL }}
+          N8N_TEST_WEBHOOK_DELETE_URL: ${{ secrets.N8N_TEST_WEBHOOK_DELETE_URL }}
       
       # Generate test summary
       - name: Generate test summary

.gitignore

@@ -89,6 +89,13 @@ docker-compose.override.yml
 temp/
 tmp/
 
+# Batch processing error files (may contain API tokens from templates)
+docs/batch_*.jsonl
+**/batch_*_error.jsonl
+
+# Local documentation and analysis files
+docs/local/
+
 # Database files
 # Database files - nodes.db is now tracked directly
 # data/*.db
@@ -130,3 +137,6 @@ n8n-mcp-wrapper.sh
 
 # MCP configuration files
 .mcp.json
+
+# Telemetry configuration (user-specific)
+~/.n8n-mcp/

CHANGELOG.md

@@ -0,0 +1,610 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.15.5] - 2025-10-04
+
+### Added
+- **Phase 5 Integration Tests** - Comprehensive workflow management tests (16 scenarios)
+  - `delete-workflow.test.ts`: 3 test scenarios
+    - Successful deletion
+    - Error handling for non-existent workflows
+    - Cleanup verification (workflow actually deleted from n8n)
+  - `list-workflows.test.ts`: 13 test scenarios
+    - No filters (all workflows)
+    - Filter by active status (true/false)
+    - Pagination (first page, cursor, last page)
+    - Limit variations (1, 50, 100)
+    - Exclude pinned data
+    - Empty results handling
+    - Sort order consistency verification
+
+### Fixed
+- **handleDeleteWorkflow** - Now returns deleted workflow data in response
+  - Before: Returned only success message
+  - After: Returns deleted workflow object per n8n API specification
+  - Impact: MCP tool consumers can access deleted workflow data for confirmation, logging, or undo operations
+
+- **handleListWorkflows Tags Filter** - Fixed tags parameter format for n8n API compliance
+  - Before: Sent tags as array `?tags[]=tag1&tags[]=tag2` (non-functional)
+  - After: Converts to comma-separated string `?tags=tag1,tag2` per n8n OpenAPI spec
+  - Impact: Tags filtering now works correctly when listing workflows
+  - Implementation: `input.tags.join(',')` conversion in handler
+
+- **N8nApiClient.deleteWorkflow** - Return type now matches n8n API specification
+  - Before: `Promise<void>`
+  - After: `Promise<Workflow>` (returns deleted workflow object)
+  - Impact: Aligns with n8n API behavior where DELETE returns the deleted resource
+
+### Changed
+- **WorkflowListParams.tags** - Type changed for API compliance
+  - Before: `tags?: string[] | null` (incorrect)
+  - After: `tags?: string | null` (comma-separated string per n8n OpenAPI spec)
+  - Impact: Type safety now matches actual API behavior
+
+### Technical Details
+- **API Compliance**: All fixes align with n8n OpenAPI specification
+- **Backward Compatibility**: Handler maintains existing MCP tool interface (array input converted internally)
+- **Type Safety**: TypeScript types now accurately reflect n8n API contracts
+
+### Test Coverage
+- Integration tests: 71/71 passing (Phase 1-5 complete)
+- Total test scenarios across all phases: 87
+- New coverage:
+  - Workflow deletion: 3 scenarios
+  - Workflow listing with filters: 13 scenarios
+
+### Impact
+- **DELETE workflows**: Now returns workflow data for verification
+- **List with tags**: Tag filtering now functional (was broken before)
+- **API alignment**: Implementation correctly matches n8n OpenAPI specification
+- **Test reliability**: All integration tests passing in CI
+
+## [2.15.4] - 2025-10-04
+
+### Fixed
+- **Workflow Settings Updates** - Enhanced `cleanWorkflowForUpdate` to enable settings updates while maintaining Issue #248 protection
+  - Changed from always overwriting settings with `{}` to filtering to whitelisted properties
+  - Filters settings to OpenAPI spec whitelisted properties: `saveExecutionProgress`, `saveManualExecutions`, `saveDataErrorExecution`, `saveDataSuccessExecution`, `executionTimeout`, `errorWorkflow`, `timezone`, `executionOrder`
+  - Removes unsafe properties like `callerPolicy` that cause "additional properties" API errors
+  - Maintains backward compatibility: empty object `{}` still used when no settings provided
+  - Resolves conflict between preventing Issue #248 errors and enabling legitimate settings updates
+
+- **Phase 4 Integration Tests** - Fixed workflow update tests to comply with n8n API requirements
+  - Updated all `handleUpdateWorkflow` tests to include required fields: `name`, `nodes`, `connections`, `settings`
+  - Tests now fetch current workflow state before updates to obtain required fields
+  - Removed invalid "Update Connections" test that attempted to set empty connections on multi-node workflow (architecturally invalid)
+  - All 42 workflow update test scenarios now passing
+
+### Changed
+- **Settings Filtering Strategy** - Updated `cleanWorkflowForUpdate()` implementation
+  - Before: Always set `settings = {}` (prevented all settings updates)
+  - After: Filter to whitelisted properties (allows valid updates, blocks problematic ones)
+  - Impact: Users can now update workflow settings via API while staying protected from validation errors
+
+### Technical Details
+- **Whitelist-based Filtering**: Implements principle of least privilege for settings properties
+- **Reference**: Properties validated against n8n OpenAPI specification `workflowSettings` schema
+- **Security**: More secure than blacklist approach (fails safe, unknown properties filtered)
+- **Performance**: Filtering adds <1ms overhead per workflow update
+
+### Test Coverage
+- Unit tests: 72/72 passing (100% coverage for n8n-validation)
+- Integration tests: 433/433 passing (Phase 4 complete)
+- Test scenarios:
+  - Settings filtering with safe/unsafe property combinations
+  - Empty settings handling
+  - Backward compatibility verification
+  - Multi-node workflow connection validation
+
+### Impact
+- **Settings Updates**: Users can now update workflow settings (timezone, executionOrder, etc.) via API
+- **Issue #248 Protection Maintained**: `callerPolicy` and other problematic properties still filtered
+- **Test Reliability**: All Phase 4 integration tests passing in CI
+- **API Compliance**: Tests correctly implement n8n API requirements for workflow updates
+
+## [2.15.3] - 2025-10-03
+
+### Added
+- **Error Message Capture in Telemetry** - Enhanced telemetry tracking to capture actual error messages for better debugging
+  - Added optional `errorMessage` parameter to `trackError()` method
+  - Comprehensive error message sanitization to protect sensitive data
+  - Updated all production and test call sites to pass error messages
+  - Error messages now stored in telemetry events table for analysis
+
+### Security
+- **Enhanced Error Message Sanitization** - Comprehensive security hardening for telemetry data
+  - **ReDoS Prevention**: Early truncation to 1500 chars before regex processing
+  - **Full URL Redaction**: Changed from `[URL]/path` to `[URL]` to prevent API structure leakage
+  - **Correct Sanitization Order**: URLs → specific credentials → emails → generic patterns
+  - **Credential Pattern Detection**: Added AWS keys, GitHub tokens, JWT, Bearer tokens
+  - **Error Handling**: Try-catch wrapper with `[SANITIZATION_FAILED]` fallback
+  - **Stack Trace Truncation**: Limited to first 3 lines to reduce attack surface
+
+### Fixed
+- **Missing Error Messages**: Resolved issue where 272+ weekly validation errors had no error messages captured
+- **Data Leakage**: Fixed URL path preservation exposing API versions and user IDs
+- **Email Exposure**: Fixed sanitization order allowing emails in URLs to leak
+- **ReDoS Vulnerability**: Removed complex capturing regex patterns that could cause performance issues
+
+### Changed
+- **Breaking Change**: `trackError()` signature updated with 4th parameter `errorMessage?: string`
+  - All internal call sites updated in single commit (atomic change)
+  - Not backwards compatible but acceptable as all code is internal
+
+### Technical Details
+- **Sanitization Patterns**:
+  - AWS Keys: `AKIA[A-Z0-9]{16}` → `[AWS_KEY]`
+  - GitHub Tokens: `ghp_[a-zA-Z0-9]{36,}` → `[GITHUB_TOKEN]`
+  - JWT: `eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+` → `[JWT]`
+  - Bearer Tokens: `Bearer [^\s]+` → `Bearer [TOKEN]`
+  - Emails: `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}` → `[EMAIL]`
+  - Long Keys: `\b[a-zA-Z0-9_-]{32,}\b` → `[KEY]`
+  - Generic Credentials: `password/api_key/token=<value>` → `<field>=[REDACTED]`
+
+### Test Coverage
+- Added 18 new security-focused tests
+- Total telemetry tests: 269 passing
+- Coverage: 90.75% for telemetry module
+- All security patterns validated with edge cases
+
+### Performance
+- Early truncation prevents ReDoS attacks
+- Simplified regex patterns (no complex capturing groups)
+- Sanitization adds <1ms overhead per error
+- Final message truncated to 500 chars max
+
+### Impact
+- **Debugging**: Error messages now available for root cause analysis
+- **Security**: Comprehensive protection against credential leakage
+- **Performance**: Protected against ReDoS attacks
+- **Reliability**: Try-catch ensures sanitization never breaks telemetry
+
+## [2.15.2] - 2025-10-03
+
+### Fixed
+- **Template Search Performance & Reliability** - Enhanced `search_templates_by_metadata` with production-ready improvements
+  - **Ordering Stability**: Implemented CTE with VALUES clause to preserve exact Phase 1 ordering
+    - Prevents ordering discrepancies between ID selection and data fetch phases
+    - Ensures deterministic results across query phases
+  - **Defensive ID Validation**: Added type safety filters before Phase 2 query
+    - Validates only positive integers are used in the CTE
+    - Logs warnings for filtered invalid IDs
+  - **Performance Monitoring**: Added detailed timing metrics (phase1Ms, phase2Ms, totalMs)
+    - Enables quantifying optimization benefits
+    - Debug logging for all search operations
+  - **DRY Refactoring**: Extracted `buildMetadataFilterConditions` helper method
+    - Eliminates duplication between `searchTemplatesByMetadata` and `getMetadataSearchCount`
+    - Centralized filter-building logic
+
+### Added
+- **Comprehensive Test Coverage** - 31 new unit tests achieving 100% coverage for changed code
+  - `buildMetadataFilterConditions` - All filter combinations (11 tests)
+  - Performance logging validation (3 tests)
+  - ID filtering edge cases - negative, zero, non-integer, null (7 tests)
+  - `getMetadataSearchCount` - Shared helper usage (7 tests)
+  - Two-phase query optimization verification (3 tests)
+- Fixed flaky integration tests with deterministic ordering using unique view counts
+
+### Performance
+- Query optimization maintains sub-1ms Phase 1 performance
+- Two-phase approach prevents timeout on large template sets
+- CTE-based ordering adds negligible overhead (<1ms)
+
+### Test Results
+- Unit tests: 31 new tests, all passing
+- Integration tests: 36 passing, 1 skipped
+- **Coverage**: 100% for changed code (previously 36.58% patch coverage)
+
+## [2.15.0] - 2025-10-02
+
+### 🚀 Major Features
+
+#### P0-R3: Pre-extracted Template Configurations
+- **Template-Based Configuration System** - 2,646 real-world node configurations from popular templates
+  - Pre-extracted node configurations from all workflow templates
+  - Ranked by template popularity (views)
+  - Includes metadata: complexity, use cases, credentials, expressions
+  - Query performance: <1ms (vs 30-60ms with previous system)
+  - Database size increase: ~513 KB for 2,000+ configurations
+
+### Breaking Changes
+
+#### Removed: `get_node_for_task` Tool
+- **Reason**: Only 31 hardcoded tasks, 28% failure rate in production
+- **Replacement**: Template-based examples with 2,646 real configurations
+
+#### Migration Guide
+
+**Before (v2.14.7):**
+```javascript
+// Get configuration for a task
+get_node_for_task({ task: "receive_webhook" })
+```
+
+**After (v2.15.0):**
+```javascript
+// Option 1: Search nodes with examples
+search_nodes({
+  query: "webhook",
+  includeExamples: true
+})
+// Returns: Top 2 real template configs per node
+
+// Option 2: Get node essentials with examples
+get_node_essentials({
+  nodeType: "nodes-base.webhook",
+  includeExamples: true
+})
+// Returns: Top 3 real template configs with full metadata
+```
+
+### Added
+
+- **Enhanced `search_nodes` Tool**
+  - New parameter: `includeExamples` (boolean, default: false)
+  - Returns top 2 real-world configurations per node from popular templates
+  - Includes: configuration, template name, view count
+
+- **Enhanced `get_node_essentials` Tool**
+  - New parameter: `includeExamples` (boolean, default: false)
+  - Returns top 3 real-world configurations with full metadata
+  - Includes: configuration, source template, complexity, use cases, credentials info
+
+- **Database Schema**
+  - New table: `template_node_configs` - Pre-extracted node configurations
+  - New view: `ranked_node_configs` - Easy access to top 5 configs per node
+  - Optimized indexes for fast queries (<1ms)
+
+- **Template Processing**
+  - Automatic config extraction during `npm run fetch:templates`
+  - Standalone extraction mode: `npm run fetch:templates:extract`
+  - Expression detection ({{...}}, $json, $node)
+  - Complexity analysis and use case extraction
+  - Ranking by template popularity
+  - Auto-creates `template_node_configs` table if missing
+
+- **Comprehensive Test Suite**
+  - 85+ tests covering all aspects of template configuration system
+  - Integration tests for database operations and end-to-end workflows
+  - Unit tests for tool parameters, extraction logic, and ranking algorithm
+  - Fixtures for consistent test data across test suites
+  - Test documentation in P0-R3-TEST-PLAN.md
+
+### Removed
+
+- Tool: `get_node_for_task` (see Breaking Changes above)
+- Tool documentation: `get-node-for-task.ts`
+
+### Fixed
+
+- **`search_nodes` includeExamples Support**
+  - Fixed `includeExamples` parameter not working due to missing FTS5 table
+  - Added example support to `searchNodesLIKE` fallback method
+  - Now returns template-based examples in all search scenarios
+  - Affects 100% of search_nodes calls (database lacks nodes_fts table)
+
+### Deprecated
+
+- `TaskTemplates` service marked for removal in v2.16.0
+- `list_tasks` tool marked for deprecation (use template search instead)
+
+### Performance
+
+- Query time: <1ms for pre-extracted configs (vs 30-60ms for on-demand generation)
+- 30-60x faster configuration lookups
+- 85x more configuration examples (2,646 vs 31)
+
+## [2.14.7] - 2025-10-02
+
+### Fixed
+- **Issue #248: Settings Validation Error** - Fixed "settings must NOT have additional properties" API errors
+  - Added `callerPolicy` property to `workflowSettingsSchema` to support valid n8n workflow setting
+  - Implemented whitelist-based settings filtering in `cleanWorkflowForUpdate()` to prevent API errors
+  - Filter removes UI-only properties (e.g., `timeSavedPerExecution`) that cause validation failures
+  - Only whitelisted properties are sent to n8n API: `executionOrder`, `timezone`, `saveDataErrorExecution`, `saveDataSuccessExecution`, `saveManualExecutions`, `saveExecutionProgress`, `executionTimeout`, `errorWorkflow`, `callerPolicy`
+  - Resolves workflow update failures caused by workflows fetched from n8n containing non-standard properties
+  - Added 6 comprehensive unit tests covering settings filtering scenarios
+
+- **Issue #249: Misleading AddConnection Error Messages** - Enhanced parameter validation with helpful error messages
+  - Detect common parameter mistakes: using `sourceNodeId`/`targetNodeId` instead of correct `source`/`target`
+  - Improved error messages include:
+    - Identification of wrong parameter names with correction guidance
+    - Examples of correct usage
+    - List of available nodes when source/target not found
+  - Error messages now actionable instead of cryptic (was: "Source node not found: undefined")
+  - Added 8 comprehensive unit tests for parameter validation scenarios
+
+- **P0-R1: Universal Node Type Normalization** - Eliminates 80% of validation errors
+  - Implemented `NodeTypeNormalizer` utility for consistent node type handling
+  - Automatically converts short forms to full forms (e.g., `nodes-base.webhook` → `n8n-nodes-base.webhook`)
+  - Applied normalization across all workflow validation entry points
+  - Updated workflow validator, handlers, and repository for universal normalization
+  - Fixed test expectations to match normalized node type format
+  - Resolves the single largest source of validation errors in production
+
+### Added
+- `NodeTypeNormalizer` utility class for universal node type normalization
+  - `normalizeToFullForm()` - Convert any node type variation to canonical form
+  - `normalizeWithDetails()` - Get normalization result with metadata
+  - `normalizeWorkflowNodeTypes()` - Batch normalize all nodes in a workflow
+- Settings whitelist filtering in `cleanWorkflowForUpdate()` with comprehensive null-safety
+- Enhanced `validateAddConnection()` with proactive parameter validation
+- 14 new unit tests for issues #248 and #249 fixes
+
+### Changed
+- Node repository now uses `NodeTypeNormalizer` for all lookups
+- Workflow validation applies normalization before structure checks
+- Workflow diff engine validates connection parameters before processing
+- Settings filtering applied to all workflow update operations
+
+### Performance
+- No performance impact - normalization adds <1ms overhead per workflow
+- Settings filtering is O(9) - negligible impact
+
+### Test Coverage
+- n8n-validation tests: 73/73 passing (100% coverage)
+- workflow-diff-engine tests: 110/110 passing (89.72% coverage)
+- Total: 183 tests passing
+
+### Impact
+- **Issue #248**: Eliminates ALL settings validation errors for workflows with non-standard properties
+- **Issue #249**: Provides clear, actionable error messages reducing user frustration
+- **P0-R1**: Reduces validation error rate by 80% (addresses 4,800+ weekly errors)
+- Combined impact: Expected overall error rate reduction from 5-10% to <2%
+
+## [2.14.6] - 2025-10-01
+
+### Enhanced
+- **Webhook Error Messages**: Replaced generic "Please try again later or contact support" messages with actionable guidance
+  - Error messages now extract execution ID and workflow ID from failed webhook triggers
+  - Guide users to use `n8n_get_execution({id: executionId, mode: 'preview'})` for efficient debugging
+  - Format: "Workflow {workflowId} execution {executionId} failed. Use n8n_get_execution({id: '{executionId}', mode: 'preview'}) to investigate the error."
+  - When no execution ID available: "Workflow failed to execute. Use n8n_list_executions to find recent executions, then n8n_get_execution with mode='preview' to investigate."
+
+### Added
+- New error formatting functions in `n8n-errors.ts`:
+  - `formatExecutionError()` - Creates execution-specific error messages with debugging guidance
+  - `formatNoExecutionError()` - Provides guidance when execution context unavailable
+- Enhanced `McpToolResponse` type with optional `executionId` and `workflowId` fields
+- Error handling documentation in `n8n-trigger-webhook-workflow` tool docs
+- 30 new comprehensive tests for error message formatting and webhook error handling
+
+### Changed
+- `handleTriggerWebhookWorkflow` now extracts execution context from error responses
+- `getUserFriendlyErrorMessage` returns actual server error messages instead of generic text
+- Tool documentation type enhanced with optional `errorHandling` field
+
+### Fixed
+- Test expectations updated to match new error message format (handlers-workflow-diff.test.ts)
+
+### Benefits
+- **Fast debugging**: Preview mode executes in <50ms (vs seconds for full data)
+- **Efficient**: Uses ~500 tokens (vs 50K+ tokens for full execution data)
+- **Safe**: No timeout or token limit risks
+- **Actionable**: Clear next steps for users to investigate failures
+
+### Impact
+- Eliminates unhelpful "contact support" messages
+- Provides specific, actionable debugging guidance
+- Reduces debugging time by directing users to efficient tools
+- 100% backward compatible - only improves error messages
+
+## [2.14.5] - 2025-09-30
+
+### Added
+- **Intelligent Execution Data Filtering**: Major enhancement to `n8n_get_execution` tool to handle large datasets without exceeding token limits
+  - **Preview Mode**: Shows data structure, counts, and size estimates without actual data (~500 tokens)
+  - **Summary Mode**: Returns 2 sample items per node (safe default, ~2-5K tokens)
+  - **Filtered Mode**: Granular control with node filtering and custom item limits
+  - **Full Mode**: Complete data retrieval (explicit opt-in)
+  - Smart recommendations based on data size (guides optimal retrieval strategy)
+  - Structure-only mode (`itemsLimit: 0`) to see data schema without values
+  - Node-specific filtering with `nodeNames` parameter
+  - Input data inclusion option for debugging transformations
+  - Automatic size estimation and token consumption guidance
+
+### Enhanced
+- `n8n_get_execution` tool with new parameters:
+  - `mode`: 'preview' | 'summary' | 'filtered' | 'full'
+  - `nodeNames`: Filter to specific nodes
+  - `itemsLimit`: Control items per node (0=structure, -1=unlimited, default=2)
+  - `includeInputData`: Include input data for debugging
+  - Legacy `includeData` parameter mapped to new modes for backward compatibility
+- Tool documentation with comprehensive examples and best practices
+- Type system with new interfaces: `ExecutionMode`, `ExecutionPreview`, `ExecutionFilterOptions`, `FilteredExecutionResponse`
+
+### Technical Improvements
+- New `ExecutionProcessor` service with intelligent filtering logic
+- Smart data truncation with metadata (`hasMoreData`, `truncated` flags)
+- Validation for `itemsLimit` (capped at 1000, negative values default to 2)
+- Error message extraction helper for consistent error handling
+- Constants-based thresholds for easy tuning (20/50/100KB limits)
+- 33 comprehensive unit tests with 78% coverage
+- Null-safe data access throughout
+
+### Performance
+- Preview mode: <50ms (no data, just structure)
+- Summary mode: <200ms (2 items per node)
+- Filtered mode: 50-500ms (depends on filters)
+- Size estimation within 10-20% accuracy
+
+### Impact
+- Solves token limit issues when inspecting large workflow executions
+- Enables AI agents to understand execution data without overwhelming responses
+- Reduces token usage by 80-95% for large datasets (50+ items)
+- Maintains 100% backward compatibility with existing integrations
+- Recommended workflow: preview → recommendation → filtered/summary
+
+### Fixed
+- Preview mode bug: Fixed API data fetching logic to ensure preview mode retrieves execution data for structure analysis and recommendation generation
+  - Changed `fetchFullData` condition in handlers-n8n-manager.ts to include preview mode
+  - Preview mode now correctly returns structure, item counts, and size estimates
+  - Recommendations are now accurate and prevent token overflow issues
+
+### Migration Guide
+- **No breaking changes**: Existing `n8n_get_execution` calls work unchanged
+- New recommended workflow:
+  1. Call with `mode: 'preview'` to assess data size
+  2. Follow `recommendation.suggestedMode` from preview
+  3. Use `mode: 'filtered'` with `itemsLimit` for precise control
+- Legacy `includeData: true` now maps to `mode: 'summary'` (safer default)
+
+## [2.14.4] - 2025-09-30
+
+### Added
+- **Workflow Cleanup Operations**: Two new operations for `n8n_update_partial_workflow`
+  - `cleanStaleConnections`: Automatically removes connections referencing non-existent nodes
+  - `replaceConnections`: Replace entire connections object in a single operation
+- **Graceful Error Handling**: Enhanced `removeConnection` with `ignoreErrors` flag
+- **Best-Effort Mode**: New `continueOnError` mode for `WorkflowDiffRequest`
+  - Apply valid operations even if some fail
+  - Returns detailed results with `applied` and `failed` operation indices
+  - Maintains atomic mode as default for safety
+
+### Enhanced
+- Tool documentation for workflow cleanup scenarios
+- Type system with new operation interfaces
+- 15 new tests covering all new features
+
+### Impact
+- Reduces broken workflow fix time from 10-15 minutes to 30 seconds
+- Token efficiency: `cleanStaleConnections` is 1 operation vs 10+ manual operations
+- 100% backwards compatibility maintained
+
+## [2.14.3] - 2025-09-30
+
+### Added
+- Incremental template updates with `npm run fetch:templates:update`
+- Smart filtering for new templates (5-10 min vs 30-40 min full rebuild)
+- 48 new templates (2,598 → 2,646 total)
+
+### Fixed
+- Template metadata generation: Updated to `gpt-4o-mini-2025-08-07` model
+- Removed unsupported `temperature` parameter from OpenAI Batch API
+- Template sanitization: Added Airtable PAT and GitHub token detection
+- Sanitized 24 templates removing API tokens
+
+### Updated
+- n8n: 1.112.3 → 1.113.3
+- n8n-core: 1.111.0 → 1.112.1
+- n8n-workflow: 1.109.0 → 1.110.0
+- @n8n/n8n-nodes-langchain: 1.111.1 → 1.112.2
+- Node database rebuilt with 536 nodes from n8n v1.113.3
+
+## [2.14.2] - 2025-09-29
+
+### Fixed
+- Validation false positives for Google Drive nodes with 'fileFolder' resource
+  - Added node type normalization to handle both `n8n-nodes-base.` and `nodes-base.` prefixes correctly
+  - Fixed resource validation to properly recognize all valid resource types
+  - Default operations are now properly applied when not specified
+  - Property visibility is now correctly checked with defaults applied
+- Code node validation incorrectly flagging valid n8n expressions as syntax errors
+  - Removed overly aggressive regex pattern `/\)\s*\)\s*{/` that flagged valid expressions
+  - Valid patterns like `$('NodeName').first().json` are now correctly recognized
+  - Function chaining and method chaining no longer trigger false positives
+- Enhanced error handling in repository methods based on code review feedback
+  - Added try-catch blocks to `getNodePropertyDefaults` and `getDefaultOperationForResource`
+  - Validates data structures before accessing to prevent crashes with malformed node data
+  - Returns safe defaults on errors to ensure validation continues
+
+### Added
+- Comprehensive test coverage for validation fixes in `tests/unit/services/validation-fixes.test.ts`
+- New repository methods for better default value handling:
+  - `getNodePropertyDefaults()` - retrieves default values for node properties
+  - `getDefaultOperationForResource()` - gets default operation for a specific resource
+
+### Changed
+- Enhanced `filterPropertiesByMode` to return both filtered properties and config with defaults applied
+- Improved node type validation to accept both valid prefix formats
+
+## [2.14.1] - 2025-09-26
+
+### Changed
+- **BREAKING**: Refactored telemetry system with major architectural improvements
+  - Split 636-line TelemetryManager into 7 focused modules (event-tracker, batch-processor, event-validator, rate-limiter, circuit-breaker, workflow-sanitizer, config-manager)
+  - Changed TelemetryManager constructor to private, use `getInstance()` method now
+  - Implemented lazy initialization pattern to avoid early singleton creation
+
+### Added
+- Security & Privacy enhancements for telemetry:
+  - Comprehensive input validation with Zod schemas
+  - Enhanced sanitization of sensitive data (URLs, API keys, emails)
+  - Expanded sensitive key detection patterns (25+ patterns)
+  - Row Level Security on Supabase backend
+  - Data deletion contact info (romuald@n8n-mcp.com)
+- Performance & Reliability improvements:
+  - Sliding window rate limiter (100 events/minute)
+  - Circuit breaker pattern for network failures
+  - Dead letter queue for failed events
+  - Exponential backoff with jitter for retries
+  - Performance monitoring with overhead tracking (<5%)
+  - Memory-safe array limits in rate limiter
+- Comprehensive test coverage enhancements:
+  - Added 662 lines of new telemetry tests
+  - Enhanced config-manager tests with 17 new edge cases
+  - Enhanced workflow-sanitizer tests with 19 new edge cases
+  - Improved coverage from 63% to 91% for telemetry module
+  - Branch coverage improved from 69% to 87%
+
+### Fixed
+- TypeScript lint errors in telemetry test files
+  - Corrected variable name conflicts in integration tests
+  - Fixed process.exit mock implementation in batch-processor tests
+  - Fixed tuple type annotations for workflow node positions
+  - Resolved MockInstance type import issues
+- Test failures in CI pipeline
+  - Fixed test timeouts caused by improper fake timer usage
+  - Resolved Timer.unref() compatibility issues
+  - Fixed event validator filtering standalone 'key' property
+  - Corrected batch processor circuit breaker behavior
+- TypeScript error in telemetry test preventing CI build
+- Added @supabase/supabase-js to Docker builder stage and runtime dependencies
+
+## [2.14.0] - 2025-09-26
+
+### Added
+- Anonymous telemetry system with Supabase integration to understand usage patterns
+  - Tracks active users with deterministic anonymous IDs
+  - Records MCP tool usage frequency and error rates
+  - Captures sanitized workflow structures on successful validation
+  - Monitors common error patterns for improvement insights
+  - Zero-configuration design with opt-out support via N8N_MCP_TELEMETRY_DISABLED environment variable
+
+- Enhanced telemetry tracking methods:
+  - `trackSearchQuery` - Records search patterns and result counts
+  - `trackValidationDetails` - Captures validation errors and warnings
+  - `trackToolSequence` - Tracks AI agent tool usage sequences
+  - `trackNodeConfiguration` - Records common node configuration patterns
+  - `trackPerformanceMetric` - Monitors operation performance
+
+- Privacy-focused workflow sanitization:
+  - Removes all sensitive data (URLs, API keys, credentials)
+  - Generates workflow hashes for deduplication
+  - Preserves only structural information
+
+- Comprehensive test coverage for telemetry components (91%+ coverage)
+
+### Fixed
+- Fixed TypeErrors in `get_node_info`, `get_node_essentials`, and `get_node_documentation` tools that were affecting 50% of calls
+- Added null safety checks for undefined node properties
+- Fixed multi-process telemetry issues with immediate flush strategy
+- Resolved RLS policy and permission issues with Supabase
+
+### Changed
+- Updated Docker configuration to include Supabase client for telemetry support
+- Enhanced workflow validation tools to track validated workflows
+- Improved error handling with proper null coalescing operators
+
+### Documentation
+- Added PRIVACY.md with comprehensive privacy policy
+- Added telemetry configuration instructions to README
+- Updated CLAUDE.md with telemetry system architecture
+
+## Previous Versions
+
+For changes in previous versions, please refer to the git history and release notes.

Dockerfile

@@ -15,7 +15,7 @@ RUN --mount=type=cache,target=/root/.npm \
     npm install --no-save typescript@^5.8.3 @types/node@^22.15.30 @types/express@^5.0.3 \
         @modelcontextprotocol/sdk@^1.12.1 dotenv@^16.5.0 express@^5.1.0 axios@^1.10.0 \
         n8n-workflow@^1.96.0 uuid@^11.0.5 @types/uuid@^10.0.0 \
-        openai@^4.77.0 zod@^3.24.1 lru-cache@^11.2.1
+        openai@^4.77.0 zod@^3.24.1 lru-cache@^11.2.1 @supabase/supabase-js@^2.57.4
 
 # Copy source and build
 COPY src ./src
@@ -74,6 +74,10 @@ USER nodejs
 # Set Docker environment flag
 ENV IS_DOCKER=true
 
+# Telemetry: Anonymous usage statistics are ENABLED by default
+# To opt-out, uncomment the following line:
+# ENV N8N_MCP_TELEMETRY_DISABLED=true
+
 # Expose HTTP port
 EXPOSE 3000
 

MEMORY_TEMPLATE_UPDATE.md

@@ -0,0 +1,336 @@
+# Template Update Process - Quick Reference
+
+## Overview
+
+The n8n-mcp project maintains a database of workflow templates from n8n.io. This guide explains how to update the template database incrementally without rebuilding from scratch.
+
+## Current Database State
+
+As of the last update:
+- **2,598 templates** in database
+- Templates from the last 12 months
+- Latest template: September 12, 2025
+
+## Quick Commands
+
+### Incremental Update (Recommended)
+```bash
+# Build if needed
+npm run build
+
+# Fetch only NEW templates (5-10 minutes)
+npm run fetch:templates:update
+```
+
+### Full Rebuild (Rare)
+```bash
+# Rebuild entire database from scratch (30-40 minutes)
+npm run fetch:templates
+```
+
+## How It Works
+
+### Incremental Update Mode (`--update`)
+
+The incremental update is **smart and efficient**:
+
+1. **Loads existing template IDs** from database (~2,598 templates)
+2. **Fetches template list** from n8n.io API (all templates from last 12 months)
+3. **Filters** to find only NEW templates not in database
+4. **Fetches details** for new templates only (saves time and API calls)
+5. **Saves** new templates to database (existing ones untouched)
+6. **Rebuilds FTS5** search index for new templates
+
+### Key Benefits
+
+✅ **Non-destructive**: All existing templates preserved
+✅ **Fast**: Only fetches new templates (5-10 min vs 30-40 min)
+✅ **API friendly**: Reduces load on n8n.io API
+✅ **Safe**: Preserves AI-generated metadata
+✅ **Smart**: Automatically skips duplicates
+
+## Performance Comparison
+
+| Mode | Templates Fetched | Time | Use Case |
+|------|------------------|------|----------|
+| **Update** | Only new (~50-200) | 5-10 min | Regular updates |
+| **Rebuild** | All (~8000+) | 30-40 min | Initial setup or corruption |
+
+## Command Options
+
+### Basic Update
+```bash
+npm run fetch:templates:update
+```
+
+### Full Rebuild
+```bash
+npm run fetch:templates
+```
+
+### With Metadata Generation
+```bash
+# Update templates and generate AI metadata
+npm run fetch:templates -- --update --generate-metadata
+
+# Or just generate metadata for existing templates
+npm run fetch:templates -- --metadata-only
+```
+
+### Help
+```bash
+npm run fetch:templates -- --help
+```
+
+## Update Frequency
+
+Recommended update schedule:
+- **Weekly**: Run incremental update to get latest templates
+- **Monthly**: Review database statistics
+- **As needed**: Rebuild only if database corruption suspected
+
+## Template Filtering
+
+The fetcher automatically filters templates:
+- ✅ **Includes**: Templates from last 12 months
+- ✅ **Includes**: Templates with >10 views
+- ❌ **Excludes**: Templates with ≤10 views (too niche)
+- ❌ **Excludes**: Templates older than 12 months
+
+## Workflow
+
+### Regular Update Workflow
+
+```bash
+# 1. Check current state
+sqlite3 data/nodes.db "SELECT COUNT(*) FROM templates"
+
+# 2. Build project (if code changed)
+npm run build
+
+# 3. Run incremental update
+npm run fetch:templates:update
+
+# 4. Verify new templates added
+sqlite3 data/nodes.db "SELECT COUNT(*) FROM templates"
+```
+
+### After n8n Dependency Update
+
+When you update n8n dependencies, templates remain compatible:
+```bash
+# 1. Update n8n (from MEMORY_N8N_UPDATE.md)
+npm run update:all
+
+# 2. Fetch new templates incrementally
+npm run fetch:templates:update
+
+# 3. Check how many templates were added
+sqlite3 data/nodes.db "SELECT COUNT(*) FROM templates"
+
+# 4. Generate AI metadata for new templates (optional, requires OPENAI_API_KEY)
+npm run fetch:templates -- --metadata-only
+
+# 5. IMPORTANT: Sanitize templates before pushing database
+npm run build
+npm run sanitize:templates
+```
+
+Templates are independent of n8n version - they're just workflow JSON data.
+
+**CRITICAL**: Always run `npm run sanitize:templates` before pushing the database to remove API tokens from template workflows.
+
+**Note**: New templates fetched via `--update` mode will NOT have AI-generated metadata by default. You need to run `--metadata-only` separately to generate metadata for templates that don't have it yet.
+
+## Troubleshooting
+
+### No New Templates Found
+
+This is normal! It means:
+- All recent templates are already in your database
+- n8n.io hasn't published many new templates recently
+- Your database is up to date
+
+```bash
+📊 Update mode: 0 new templates to fetch (skipping 2598 existing)
+✅ All templates already have metadata
+```
+
+### API Rate Limiting
+
+If you hit rate limits:
+- The fetcher includes built-in delays (150ms between requests)
+- Wait a few minutes and try again
+- Use `--update` mode instead of full rebuild
+
+### Database Corruption
+
+If you suspect corruption:
+```bash
+# Full rebuild from scratch
+npm run fetch:templates
+
+# This will:
+# - Drop and recreate templates table
+# - Fetch all templates fresh
+# - Rebuild search indexes
+```
+
+## Database Schema
+
+Templates are stored with:
+- Basic info (id, name, description, author, views, created_at)
+- Node types used (JSON array)
+- Complete workflow (gzip compressed, base64 encoded)
+- AI-generated metadata (optional, requires OpenAI API key)
+- FTS5 search index for fast text search
+
+## Metadata Generation
+
+Generate AI metadata for templates:
+```bash
+# Requires OPENAI_API_KEY in .env
+export OPENAI_API_KEY="sk-..."
+
+# Generate for templates without metadata (recommended after incremental update)
+npm run fetch:templates -- --metadata-only
+
+# Generate during template fetch (slower, but automatic)
+npm run fetch:templates:update -- --generate-metadata
+```
+
+**Important**: Incremental updates (`--update`) do NOT generate metadata by default. After running `npm run fetch:templates:update`, you'll have new templates without metadata. Run `--metadata-only` separately to generate metadata for them.
+
+### Check Metadata Coverage
+
+```bash
+# See how many templates have metadata
+sqlite3 data/nodes.db "SELECT
+  COUNT(*) as total,
+  SUM(CASE WHEN metadata_json IS NOT NULL THEN 1 ELSE 0 END) as with_metadata,
+  SUM(CASE WHEN metadata_json IS NULL THEN 1 ELSE 0 END) as without_metadata
+FROM templates"
+
+# See recent templates without metadata
+sqlite3 data/nodes.db "SELECT id, name, created_at
+FROM templates
+WHERE metadata_json IS NULL
+ORDER BY created_at DESC
+LIMIT 10"
+```
+
+Metadata includes:
+- Categories
+- Complexity level (simple/medium/complex)
+- Use cases
+- Estimated setup time
+- Required services
+- Key features
+- Target audience
+
+### Metadata Generation Troubleshooting
+
+If metadata generation fails:
+
+1. **Check error file**: Errors are saved to `temp/batch/batch_*_error.jsonl`
+2. **Common issues**:
+   - `"Unsupported value: 'temperature'"` - Model doesn't support custom temperature
+   - `"Invalid request"` - Check OPENAI_API_KEY is valid
+   - Model availability issues
+3. **Model**: Uses `gpt-5-mini-2025-08-07` by default
+4. **Token limit**: 3000 tokens per request for detailed metadata
+
+The system will automatically:
+- Process error files and assign default metadata to failed templates
+- Save error details for debugging
+- Continue processing even if some templates fail
+
+**Example error handling**:
+```bash
+# If you see: "No output file available for batch job"
+# Check: temp/batch/batch_*_error.jsonl for error details
+# The system now automatically processes errors and generates default metadata
+```
+
+## Environment Variables
+
+Optional configuration:
+```bash
+# OpenAI for metadata generation
+OPENAI_API_KEY=sk-...
+OPENAI_MODEL=gpt-4o-mini  # Default model
+OPENAI_BATCH_SIZE=50      # Batch size for metadata generation
+
+# Metadata generation limits
+METADATA_LIMIT=100        # Max templates to process (0 = all)
+```
+
+## Statistics
+
+After update, check stats:
+```bash
+# Template count
+sqlite3 data/nodes.db "SELECT COUNT(*) FROM templates"
+
+# Most recent template
+sqlite3 data/nodes.db "SELECT MAX(created_at) FROM templates"
+
+# Templates by view count
+sqlite3 data/nodes.db "SELECT COUNT(*),
+  CASE
+    WHEN views < 50 THEN '<50'
+    WHEN views < 100 THEN '50-100'
+    WHEN views < 500 THEN '100-500'
+    ELSE '500+'
+  END as view_range
+  FROM templates GROUP BY view_range"
+```
+
+## Integration with n8n-mcp
+
+Templates are available through MCP tools:
+- `list_templates`: List all templates
+- `get_template`: Get specific template with workflow
+- `search_templates`: Search by keyword
+- `list_node_templates`: Templates using specific nodes
+- `get_templates_for_task`: Templates for common tasks
+- `search_templates_by_metadata`: Advanced filtering
+
+See `npm run test:templates` for usage examples.
+
+## Time Estimates
+
+Typical incremental update:
+- Loading existing IDs: 1-2 seconds
+- Fetching template list: 2-3 minutes
+- Filtering new templates: instant
+- Fetching details for 100 new templates: ~15 seconds (0.15s each)
+- Saving and indexing: 5-10 seconds
+- **Total: 3-5 minutes**
+
+Full rebuild:
+- Fetching 8000+ templates: 25-30 minutes
+- Saving and indexing: 5-10 minutes
+- **Total: 30-40 minutes**
+
+## Best Practices
+
+1. **Use incremental updates** for regular maintenance
+2. **Rebuild only when necessary** (corruption, major changes)
+3. **Generate metadata incrementally** to avoid OpenAI costs
+4. **Monitor template count** to verify updates working
+5. **Keep database backed up** before major operations
+
+## Next Steps
+
+After updating templates:
+1. Test template search: `npm run test:templates`
+2. Verify MCP tools work: Test in Claude Desktop
+3. Check statistics in database
+4. Commit changes if desired (database changes)
+
+## Related Documentation
+
+- `MEMORY_N8N_UPDATE.md` - Updating n8n dependencies
+- `CLAUDE.md` - Project overview and architecture
+- `README.md` - User documentation

P0-R3-TEST-PLAN.md

@@ -0,0 +1,484 @@
+# P0-R3 Feature Test Coverage Plan
+
+## Executive Summary
+
+This document outlines comprehensive test coverage for the P0-R3 feature (Template-based Configuration Examples). The feature adds real-world configuration examples from popular templates to node search and essentials tools.
+
+**Feature Overview:**
+- New database table: `template_node_configs` (197 pre-extracted configurations)
+- Enhanced tools: `search_nodes({includeExamples: true})` and `get_node_essentials({includeExamples: true})`
+- Breaking changes: Removed `get_node_for_task` tool
+
+## Test Files Created
+
+### Unit Tests
+
+#### 1. `/tests/unit/scripts/fetch-templates-extraction.test.ts` ✅
+**Purpose:** Test template extraction logic from `fetch-templates.ts`
+
+**Coverage:**
+- `extractNodeConfigs()` - 90%+ coverage
+  - Valid workflows with multiple nodes
+  - Empty workflows
+  - Malformed compressed data
+  - Invalid JSON
+  - Nodes without parameters
+  - Sticky note filtering
+  - Credential handling
+  - Expression detection
+  - Special characters
+  - Large workflows (100 nodes)
+
+- `detectExpressions()` - 100% coverage
+  - `={{...}}` syntax detection
+  - `$json` references
+  - `$node` references
+  - Nested objects
+  - Arrays
+  - Null/undefined handling
+  - Multiple expression types
+
+**Test Count:** 27 tests
+**Expected Coverage:** 92%+
+
+---
+
+#### 2. `/tests/unit/mcp/search-nodes-examples.test.ts` ✅
+**Purpose:** Test `search_nodes` tool with includeExamples parameter
+
+**Coverage:**
+- includeExamples parameter behavior
+  - false: no examples returned
+  - undefined: no examples returned (default)
+  - true: examples returned
+- Example data structure validation
+- Top 2 limit enforcement
+- Backward compatibility
+- Performance (<100ms)
+- Error handling (malformed JSON, database errors)
+- searchNodesLIKE integration
+- searchNodesFTS integration
+
+**Test Count:** 12 tests
+**Expected Coverage:** 85%+
+
+---
+
+#### 3. `/tests/unit/mcp/get-node-essentials-examples.test.ts` ✅
+**Purpose:** Test `get_node_essentials` tool with includeExamples parameter
+
+**Coverage:**
+- includeExamples parameter behavior
+- Full metadata structure
+  - configuration object
+  - source (template, views, complexity)
+  - useCases (limited to 2)
+  - metadata (hasCredentials, hasExpressions)
+- Cache key differentiation
+- Backward compatibility
+- Performance (<100ms)
+- Error handling
+- Top 3 limit enforcement
+
+**Test Count:** 13 tests
+**Expected Coverage:** 88%+
+
+---
+
+### Integration Tests
+
+#### 4. `/tests/integration/database/template-node-configs.test.ts` ✅
+**Purpose:** Test database schema, migrations, and operations
+
+**Coverage:**
+- Schema validation
+  - Table creation
+  - All columns present
+  - Correct types and constraints
+  - CHECK constraint on complexity
+- Indexes
+  - idx_config_node_type_rank
+  - idx_config_complexity
+  - idx_config_auth
+- View: ranked_node_configs
+  - Top 5 per node_type
+  - Correct ordering
+- Foreign key constraints
+  - CASCADE delete
+  - Referential integrity
+- Data operations
+  - INSERT with all fields
+  - Nullable fields
+  - Rank updates
+  - Delete rank > 10
+- Performance
+  - 1000 records < 10ms queries
+- Migration idempotency
+
+**Test Count:** 19 tests
+**Expected Coverage:** 95%+
+
+---
+
+#### 5. `/tests/integration/mcp/template-examples-e2e.test.ts` ✅
+**Purpose:** End-to-end integration testing
+
+**Coverage:**
+- Direct SQL queries
+  - Top 2 examples for search_nodes
+  - Top 3 examples with metadata for get_node_essentials
+- Data structure validation
+  - Valid JSON in all fields
+  - Credentials when has_credentials=1
+- Ranked view functionality
+- Performance with 100+ configs
+  - Query performance < 5ms
+  - Complexity filtering
+- Edge cases
+  - Non-existent node types
+  - Long parameters_json (100 params)
+  - Special characters (Unicode, emojis, symbols)
+- Data integrity
+  - Foreign key constraints
+  - Cascade deletes
+
+**Test Count:** 14 tests
+**Expected Coverage:** 90%+
+
+---
+
+### Test Fixtures
+
+#### 6. `/tests/fixtures/template-configs.ts` ✅
+**Purpose:** Reusable test data
+
+**Provides:**
+- `sampleConfigs`: 7 realistic node configurations
+  - simpleWebhook
+  - webhookWithAuth
+  - httpRequestBasic
+  - httpRequestWithExpressions
+  - slackMessage
+  - codeNodeTransform
+  - codeNodeWithExpressions
+
+- `sampleWorkflows`: 3 complete workflows
+  - webhookToSlack
+  - apiWorkflow
+  - complexWorkflow
+
+- **Helper Functions:**
+  - `compressWorkflow()` - Compress to base64
+  - `createTemplateMetadata()` - Generate metadata
+  - `createConfigBatch()` - Batch create configs
+  - `getConfigByComplexity()` - Filter by complexity
+  - `getConfigsWithExpressions()` - Filter with expressions
+  - `getConfigsWithCredentials()` - Filter with credentials
+  - `createInsertStatement()` - SQL insert helper
+
+---
+
+## Existing Tests Requiring Updates
+
+### High Priority
+
+#### 1. `tests/unit/mcp/parameter-validation.test.ts`
+**Line 480:** Remove `get_node_for_task` from legacyValidationTools array
+
+```typescript
+// REMOVE THIS:
+{ name: 'get_node_for_task', args: {}, expected: 'Missing required parameters for get_node_for_task: task' },
+```
+
+**Status:** ⚠️ BREAKING CHANGE - Tool removed
+
+---
+
+#### 2. `tests/unit/mcp/tools.test.ts`
+**Update:** Remove `get_node_for_task` from templates category
+
+```typescript
+// BEFORE:
+templates: ['list_tasks', 'get_node_for_task', 'search_templates', ...]
+
+// AFTER:
+templates: ['list_tasks', 'search_templates', ...]
+```
+
+**Add:** Tests for new includeExamples parameter in tool definitions
+
+```typescript
+it('should have includeExamples parameter in search_nodes', () => {
+  const searchNodesTool = tools.find(t => t.name === 'search_nodes');
+  expect(searchNodesTool.inputSchema.properties.includeExamples).toBeDefined();
+  expect(searchNodesTool.inputSchema.properties.includeExamples.type).toBe('boolean');
+  expect(searchNodesTool.inputSchema.properties.includeExamples.default).toBe(false);
+});
+
+it('should have includeExamples parameter in get_node_essentials', () => {
+  const essentialsTool = tools.find(t => t.name === 'get_node_essentials');
+  expect(essentialsTool.inputSchema.properties.includeExamples).toBeDefined();
+});
+```
+
+**Status:** ⚠️ REQUIRED UPDATE
+
+---
+
+#### 3. `tests/integration/mcp-protocol/session-management.test.ts`
+**Remove:** Test case calling `get_node_for_task` with invalid task
+
+```typescript
+// REMOVE THIS TEST:
+client.callTool({ name: 'get_node_for_task', arguments: { task: 'invalid_task' } }).catch(e => e)
+```
+
+**Status:** ⚠️ BREAKING CHANGE
+
+---
+
+#### 4. `tests/integration/mcp-protocol/tool-invocation.test.ts`
+**Remove:** Entire `get_node_for_task` describe block
+
+**Add:** Tests for new includeExamples functionality
+
+```typescript
+describe('search_nodes with includeExamples', () => {
+  it('should return examples when includeExamples is true', async () => {
+    const response = await client.callTool({
+      name: 'search_nodes',
+      arguments: { query: 'webhook', includeExamples: true }
+    });
+
+    expect(response.results).toBeDefined();
+    // Examples may or may not be present depending on database
+  });
+
+  it('should not return examples when includeExamples is false', async () => {
+    const response = await client.callTool({
+      name: 'search_nodes',
+      arguments: { query: 'webhook', includeExamples: false }
+    });
+
+    expect(response.results).toBeDefined();
+    response.results.forEach(node => {
+      expect(node.examples).toBeUndefined();
+    });
+  });
+});
+
+describe('get_node_essentials with includeExamples', () => {
+  it('should return examples with metadata when includeExamples is true', async () => {
+    const response = await client.callTool({
+      name: 'get_node_essentials',
+      arguments: { nodeType: 'nodes-base.webhook', includeExamples: true }
+    });
+
+    expect(response.nodeType).toBeDefined();
+    // Examples may or may not be present depending on database
+  });
+});
+```
+
+**Status:** ⚠️ REQUIRED UPDATE
+
+---
+
+### Medium Priority
+
+#### 5. `tests/unit/services/task-templates.test.ts`
+**Status:** ✅ No changes needed (TaskTemplates marked as deprecated but not removed)
+
+**Note:** TaskTemplates remains for backward compatibility. Tests should continue to pass.
+
+---
+
+## Test Execution Plan
+
+### Phase 1: Unit Tests
+```bash
+# Run new unit tests
+npm test tests/unit/scripts/fetch-templates-extraction.test.ts
+npm test tests/unit/mcp/search-nodes-examples.test.ts
+npm test tests/unit/mcp/get-node-essentials-examples.test.ts
+
+# Expected: All pass, 52 tests
+```
+
+### Phase 2: Integration Tests
+```bash
+# Run new integration tests
+npm test tests/integration/database/template-node-configs.test.ts
+npm test tests/integration/mcp/template-examples-e2e.test.ts
+
+# Expected: All pass, 33 tests
+```
+
+### Phase 3: Update Existing Tests
+```bash
+# Update files as outlined above, then run:
+npm test tests/unit/mcp/parameter-validation.test.ts
+npm test tests/unit/mcp/tools.test.ts
+npm test tests/integration/mcp-protocol/session-management.test.ts
+npm test tests/integration/mcp-protocol/tool-invocation.test.ts
+
+# Expected: All pass after updates
+```
+
+### Phase 4: Full Test Suite
+```bash
+# Run all tests
+npm test
+
+# Run with coverage
+npm run test:coverage
+
+# Expected coverage improvements:
+# - src/scripts/fetch-templates.ts: +20% (60% → 80%)
+# - src/mcp/server.ts: +5% (75% → 80%)
+# - Overall project: +2% (current → current+2%)
+```
+
+---
+
+## Coverage Expectations
+
+### New Code Coverage
+
+| File | Function | Target | Tests |
+|------|----------|--------|-------|
+| fetch-templates.ts | extractNodeConfigs | 95% | 15 tests |
+| fetch-templates.ts | detectExpressions | 100% | 12 tests |
+| server.ts | searchNodes (with examples) | 90% | 8 tests |
+| server.ts | getNodeEssentials (with examples) | 90% | 10 tests |
+| Database migration | template_node_configs | 100% | 19 tests |
+
+### Overall Coverage Goals
+
+- **Unit Tests:** 90%+ coverage for new code
+- **Integration Tests:** All happy paths + critical error paths
+- **E2E Tests:** Complete feature workflows
+- **Performance:** All queries <10ms (database), <100ms (MCP)
+
+---
+
+## Test Infrastructure
+
+### Dependencies Required
+All dependencies already present in `package.json`:
+- vitest (test runner)
+- better-sqlite3 (database)
+- @vitest/coverage-v8 (coverage)
+
+### Test Utilities Used
+- TestDatabase helper (from existing test utils)
+- createTestDatabaseAdapter (from existing test utils)
+- Standard vitest matchers
+
+### No New Dependencies Required ✅
+
+---
+
+## Regression Prevention
+
+### Critical Paths Protected
+
+1. **Backward Compatibility**
+   - Tools work without includeExamples parameter
+   - Existing workflows unchanged
+   - Cache keys differentiated
+
+2. **Performance**
+   - No degradation when includeExamples=false
+   - Indexed queries <10ms
+   - Example fetch errors don't break responses
+
+3. **Data Integrity**
+   - Foreign key constraints enforced
+   - JSON validation in all fields
+   - Rank calculations correct
+
+---
+
+## CI/CD Integration
+
+### GitHub Actions Updates
+No changes required. Existing test commands will run new tests:
+
+```yaml
+- run: npm test
+- run: npm run test:coverage
+```
+
+### Coverage Thresholds
+Current thresholds maintained. Expected improvements:
+- Lines: +2%
+- Functions: +3%
+- Branches: +2%
+
+---
+
+## Manual Testing Checklist
+
+### Pre-Deployment Verification
+
+- [ ] Run `npm run rebuild` - Verify migration applies cleanly
+- [ ] Run `npm run fetch:templates --extract-only` - Verify extraction works
+- [ ] Check database: `SELECT COUNT(*) FROM template_node_configs` - Should be ~197
+- [ ] Test MCP tool: `search_nodes({query: "webhook", includeExamples: true})`
+- [ ] Test MCP tool: `get_node_essentials({nodeType: "nodes-base.webhook", includeExamples: true})`
+- [ ] Verify backward compatibility: Tools work without includeExamples parameter
+- [ ] Performance test: Query 100 nodes with examples < 200ms
+
+---
+
+## Rollback Plan
+
+If issues are detected:
+
+1. **Database Rollback:**
+   ```sql
+   DROP TABLE IF EXISTS template_node_configs;
+   DROP VIEW IF EXISTS ranked_node_configs;
+   ```
+
+2. **Code Rollback:**
+   - Revert server.ts changes
+   - Revert tools.ts changes
+   - Restore get_node_for_task tool (if critical)
+
+3. **Test Rollback:**
+   - Revert parameter-validation.test.ts
+   - Revert tools.test.ts
+   - Revert tool-invocation.test.ts
+
+---
+
+## Success Metrics
+
+### Test Metrics
+- ✅ 85+ new tests added
+- ✅ 0 tests failing after updates
+- ✅ Coverage increase 2%+
+- ✅ All performance tests pass
+
+### Feature Metrics
+- ✅ 197 template configs extracted
+- ✅ Top 2/3 examples returned correctly
+- ✅ Query performance <10ms
+- ✅ No backward compatibility breaks
+
+---
+
+## Conclusion
+
+This test plan provides **comprehensive coverage** for the P0-R3 feature with:
+- **85+ new tests** across unit, integration, and E2E levels
+- **Complete coverage** of extraction, storage, and retrieval
+- **Backward compatibility** protection
+- **Performance validation** (<10ms queries)
+- **Clear migration path** for existing tests
+
+**All test files are ready for execution.** Update the 4 existing test files as outlined, then run the full test suite.
+
+**Estimated Total Implementation Time:** 2-3 hours for updating existing tests + validation

PRIVACY.md

@@ -0,0 +1,69 @@
+# Privacy Policy for n8n-mcp Telemetry
+
+## Overview
+n8n-mcp collects anonymous usage statistics to help improve the tool. This data collection is designed to respect user privacy while providing valuable insights into how the tool is used.
+
+## What We Collect
+- **Anonymous User ID**: A hashed identifier derived from your machine characteristics (no personal information)
+- **Tool Usage**: Which MCP tools are used and their performance metrics
+- **Workflow Patterns**: Sanitized workflow structures (all sensitive data removed)
+- **Error Types**: Categories of errors encountered (no error messages with user data)
+- **System Information**: Platform, architecture, Node.js version, and n8n-mcp version
+
+## What We DON'T Collect
+- Personal information or usernames
+- API keys, tokens, or credentials
+- URLs, endpoints, or hostnames
+- Email addresses or contact information
+- File paths or directory structures
+- Actual workflow data or parameters
+- Database connection strings
+- Any authentication information
+
+## Data Sanitization
+All collected data undergoes automatic sanitization:
+- URLs are replaced with `[URL]` or `[REDACTED]`
+- Long alphanumeric strings (potential keys) are replaced with `[KEY]`
+- Email addresses are replaced with `[EMAIL]`
+- Authentication-related fields are completely removed
+
+## Data Storage
+- Data is stored securely using Supabase
+- Anonymous users have write-only access (cannot read data back)
+- Row Level Security (RLS) policies prevent data access by anonymous users
+
+## Opt-Out
+You can disable telemetry at any time:
+```bash
+npx n8n-mcp telemetry disable
+```
+
+To re-enable:
+```bash
+npx n8n-mcp telemetry enable
+```
+
+To check status:
+```bash
+npx n8n-mcp telemetry status
+```
+
+## Data Usage
+Collected data is used solely to:
+- Understand which features are most used
+- Identify common error patterns
+- Improve tool performance and reliability
+- Guide development priorities
+
+## Data Retention
+- Data is retained for analysis purposes
+- No personal identification is possible from the collected data
+
+## Changes to This Policy
+We may update this privacy policy from time to time. Updates will be reflected in this document.
+
+## Contact
+For questions about telemetry or privacy, please open an issue on GitHub:
+https://github.com/czlonkowski/n8n-mcp/issues
+
+Last updated: 2025-09-25

README.md

@@ -2,11 +2,10 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub stars](https://img.shields.io/github/stars/czlonkowski/n8n-mcp?style=social)](https://github.com/czlonkowski/n8n-mcp)
-[![Version](https://img.shields.io/badge/version-2.12.1-blue.svg)](https://github.com/czlonkowski/n8n-mcp)
 [![npm version](https://img.shields.io/npm/v/n8n-mcp.svg)](https://www.npmjs.com/package/n8n-mcp)
 [![codecov](https://codecov.io/gh/czlonkowski/n8n-mcp/graph/badge.svg?token=YOUR_TOKEN)](https://codecov.io/gh/czlonkowski/n8n-mcp)
-[![Tests](https://img.shields.io/badge/tests-1728%20passing-brightgreen.svg)](https://github.com/czlonkowski/n8n-mcp/actions)
-[![n8n version](https://img.shields.io/badge/n8n-^1.111.0-orange.svg)](https://github.com/n8n-io/n8n)
+[![Tests](https://img.shields.io/badge/tests-3336%20passing-brightgreen.svg)](https://github.com/czlonkowski/n8n-mcp/actions)
+[![n8n version](https://img.shields.io/badge/n8n-^1.113.3-orange.svg)](https://github.com/n8n-io/n8n)
 [![Docker](https://img.shields.io/badge/docker-ghcr.io%2Fczlonkowski%2Fn8n--mcp-green.svg)](https://github.com/czlonkowski/n8n-mcp/pkgs/container/n8n-mcp)
 [![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/n8n-mcp?referralCode=n8n-mcp)
 
@@ -16,11 +15,13 @@ A Model Context Protocol (MCP) server that provides AI assistants with comprehen
 
 n8n-MCP serves as a bridge between n8n's workflow automation platform and AI models, enabling them to understand and work with n8n nodes effectively. It provides structured access to:
 
-- 📚 **535 n8n nodes** from both n8n-nodes-base and @n8n/n8n-nodes-langchain
+- 📚 **536 n8n nodes** from both n8n-nodes-base and @n8n/n8n-nodes-langchain
 - 🔧 **Node properties** - 99% coverage with detailed schemas
 - ⚡ **Node operations** - 63.6% coverage of available actions
 - 📄 **Documentation** - 90% coverage from official n8n docs (including AI nodes)
 - 🤖 **AI tools** - 263 AI-capable nodes detected with full documentation
+- 💡 **Real-world examples** - 2,646 pre-extracted configurations from popular templates
+- 🎯 **Template library** - 2,500+ workflow templates with smart filtering
 
 
 ## ⚠️ Important Safety Warning
@@ -212,6 +213,51 @@ Add to Claude Desktop config:
 
 **Restart Claude Desktop after updating configuration** - That's it! 🎉
 
+## 🔐 Privacy & Telemetry
+
+n8n-mcp collects anonymous usage statistics to improve the tool. [View our privacy policy](./PRIVACY.md).
+
+### Opting Out
+
+**For npx users:**
+```bash
+npx n8n-mcp telemetry disable
+```
+
+**For Docker users:**
+Add the following environment variable to your Docker configuration:
+```json
+"-e", "N8N_MCP_TELEMETRY_DISABLED=true"
+```
+
+Example in Claude Desktop config:
+```json
+{
+  "mcpServers": {
+    "n8n-mcp": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "--init",
+        "-e", "MCP_MODE=stdio",
+        "-e", "LOG_LEVEL=error",
+        "-e", "N8N_MCP_TELEMETRY_DISABLED=true",
+        "ghcr.io/czlonkowski/n8n-mcp:latest"
+      ]
+    }
+  }
+}
+```
+
+**For docker-compose users:**
+Set in your environment file or docker-compose.yml:
+```yaml
+environment:
+  N8N_MCP_TELEMETRY_DISABLED: "true"
+```
+
 ## 💖 Support This Project
 
 <div align="center">
@@ -346,183 +392,267 @@ Step-by-step tutorial for connecting n8n-MCP to Cursor IDE with custom rules.
 ### [Windsurf](./docs/WINDSURF_SETUP.md)
 Complete guide for integrating n8n-MCP with Windsurf using project rules.
 
+### [Codex](./docs/CODEX_SETUP.md)
+Complete guide for integrating n8n-MCP with Codex.
+
 ## 🤖 Claude Project Setup
 
 For the best results when using n8n-MCP with Claude Projects, use these enhanced system instructions:
 
-```markdown
+````markdown
 You are an expert in n8n automation software using n8n-MCP tools. Your role is to design, build, and validate n8n workflows with maximum accuracy and efficiency.
 
-## Core Workflow Process
+## Core Principles
 
-1. **ALWAYS start new conversation with**: `tools_documentation()` to understand best practices and available tools.
+### 1. Silent Execution
+CRITICAL: Execute tools without commentary. Only respond AFTER all tools complete.
 
-2. **Template Discovery Phase** 
-   - `search_templates_by_metadata({complexity: "simple"})` - Find skill-appropriate templates
-   - `get_templates_for_task('webhook_processing')` - Get curated templates by task
-   - `search_templates('slack notification')` - Text search for specific needs
-   - `list_node_templates(['n8n-nodes-base.slack'])` - Find templates using specific nodes
-   
-   **Template filtering strategies**:
-   - **For beginners**: `complexity: "simple"` and `maxSetupMinutes: 30`
-   - **By role**: `targetAudience: "marketers"` or `"developers"` or `"analysts"`
-   - **By time**: `maxSetupMinutes: 15` for quick wins
-   - **By service**: `requiredService: "openai"` to find compatible templates
+❌ BAD: "Let me search for Slack nodes... Great! Now let me get details..."
+✅ GOOD: [Execute search_nodes and get_node_essentials in parallel, then respond]
 
-3. **Discovery Phase** - Find the right nodes (if no suitable template):
-   - Think deeply about user request and the logic you are going to build to fulfill it. Ask follow-up questions to clarify the user's intent, if something is unclear. Then, proceed with the rest of your instructions.
-   - `search_nodes({query: 'keyword'})` - Search by functionality
+### 2. Parallel Execution
+When operations are independent, execute them in parallel for maximum performance.
+
+✅ GOOD: Call search_nodes, list_nodes, and search_templates simultaneously
+❌ BAD: Sequential tool calls (await each one before the next)
+
+### 3. Templates First
+ALWAYS check templates before building from scratch (2,500+ available).
+
+### 4. Multi-Level Validation
+Use validate_node_minimal → validate_node_operation → validate_workflow pattern.
+
+### 5. Never Trust Defaults
+⚠️ CRITICAL: Default parameter values are the #1 source of runtime failures.
+ALWAYS explicitly configure ALL parameters that control node behavior.
+
+## Workflow Process
+
+1. **Start**: Call `tools_documentation()` for best practices
+
+2. **Template Discovery Phase** (FIRST - parallel when searching multiple)
+   - `search_templates_by_metadata({complexity: "simple"})` - Smart filtering
+   - `get_templates_for_task('webhook_processing')` - Curated by task
+   - `search_templates('slack notification')` - Text search
+   - `list_node_templates(['n8n-nodes-base.slack'])` - By node type
+
+   **Filtering strategies**:
+   - Beginners: `complexity: "simple"` + `maxSetupMinutes: 30`
+   - By role: `targetAudience: "marketers"` | `"developers"` | `"analysts"`
+   - By time: `maxSetupMinutes: 15` for quick wins
+   - By service: `requiredService: "openai"` for compatibility
+
+3. **Node Discovery** (if no suitable template - parallel execution)
+   - Think deeply about requirements. Ask clarifying questions if unclear.
+   - `search_nodes({query: 'keyword', includeExamples: true})` - Parallel for multiple nodes
    - `list_nodes({category: 'trigger'})` - Browse by category
-   - `list_ai_tools()` - See AI-capable nodes (remember: ANY node can be an AI tool!)
+   - `list_ai_tools()` - AI-capable nodes
 
-4. **Configuration Phase** - Get node details efficiently:
-   - `get_node_essentials(nodeType)` - Start here! Only 10-20 essential properties
+4. **Configuration Phase** (parallel for multiple nodes)
+   - `get_node_essentials(nodeType, {includeExamples: true})` - 10-20 key properties
    - `search_node_properties(nodeType, 'auth')` - Find specific properties
-   - `get_node_for_task('send_email')` - Get pre-configured templates
-   - `get_node_documentation(nodeType)` - Human-readable docs when needed
-   - It is good common practice to show a visual representation of the workflow architecture to the user and asking for opinion, before moving forward. 
+   - `get_node_documentation(nodeType)` - Human-readable docs
+   - Show workflow architecture to user for approval before proceeding
 
-5. **Pre-Validation Phase** - Validate BEFORE building:
+5. **Validation Phase** (parallel for multiple nodes)
    - `validate_node_minimal(nodeType, config)` - Quick required fields check
-   - `validate_node_operation(nodeType, config, profile)` - Full operation-aware validation
-   - Fix any validation errors before proceeding
+   - `validate_node_operation(nodeType, config, 'runtime')` - Full validation with fixes
+   - Fix ALL errors before proceeding
 
-6. **Building Phase** - Create or customize the workflow:
+6. **Building Phase**
    - If using template: `get_template(templateId, {mode: "full"})`
-   - **MANDATORY ATTRIBUTION**: When using a template, ALWAYS inform the user:
-     - "This workflow is based on a template by **[author.name]** (@[author.username])"
-     - "View the original template at: [url]"
-     - Example: "This workflow is based on a template by **David Ashby** (@cfomodz). View the original at: https://n8n.io/workflows/2414"
-   - Customize template or build from validated configurations
+   - **MANDATORY ATTRIBUTION**: "Based on template by **[author.name]** (@[username]). View at: [url]"
+   - Build from validated configurations
+   - ⚠️ EXPLICITLY set ALL parameters - never rely on defaults
    - Connect nodes with proper structure
-   - Add error handling where appropriate
-   - Use expressions like $json, $node["NodeName"].json
-   - Build the workflow in an artifact for easy editing downstream (unless the user asked to create in n8n instance)
+   - Add error handling
+   - Use n8n expressions: $json, $node["NodeName"].json
+   - Build in artifact (unless deploying to n8n instance)
 
-7. **Workflow Validation Phase** - Validate complete workflow:
-   - `validate_workflow(workflow)` - Complete validation including connections
-   - `validate_workflow_connections(workflow)` - Check structure and AI tool connections
-   - `validate_workflow_expressions(workflow)` - Validate all n8n expressions
-   - Fix any issues found before deployment
+7. **Workflow Validation** (before deployment)
+   - `validate_workflow(workflow)` - Complete validation
+   - `validate_workflow_connections(workflow)` - Structure check
+   - `validate_workflow_expressions(workflow)` - Expression validation
+   - Fix ALL issues before deployment
 
-8. **Deployment Phase** (if n8n API configured):
-   - `n8n_create_workflow(workflow)` - Deploy validated workflow
-   - `n8n_validate_workflow({id: 'workflow-id'})` - Post-deployment validation
-   - `n8n_update_partial_workflow()` - Make incremental updates using diffs
-   - `n8n_trigger_webhook_workflow()` - Test webhook workflows
+8. **Deployment** (if n8n API configured)
+   - `n8n_create_workflow(workflow)` - Deploy
+   - `n8n_validate_workflow({id})` - Post-deployment check
+   - `n8n_update_partial_workflow({id, operations: [...]})` - Batch updates
+   - `n8n_trigger_webhook_workflow()` - Test webhooks
 
-## Key Insights
+## Critical Warnings
 
-- **TEMPLATES FIRST** - Always check for existing templates before building from scratch (2,500+ available!)
-- **ATTRIBUTION REQUIRED** - Always credit template authors with name, username, and link to n8n.io
-- **SMART FILTERING** - Use metadata filters to find templates matching user skill level and time constraints
-- **USE CODE NODE ONLY WHEN IT IS NECESSARY** - always prefer to use standard nodes over code node. Use code node only when you are sure you need it.
-- **VALIDATE EARLY AND OFTEN** - Catch errors before they reach deployment
-- **USE DIFF UPDATES** - Use n8n_update_partial_workflow for 80-90% token savings
-- **ANY node can be an AI tool** - not just those with usableAsTool=true
-- **Pre-validate configurations** - Use validate_node_minimal before building
-- **Post-validate workflows** - Always validate complete workflows before deployment
-- **Incremental updates** - Use diff operations for existing workflows
-- **Test thoroughly** - Validate both locally and after deployment to n8n
+### ⚠️ Never Trust Defaults
+Default values cause runtime failures. Example:
+```json
+// ❌ FAILS at runtime
+{resource: "message", operation: "post", text: "Hello"}
+
+// ✅ WORKS - all parameters explicit
+{resource: "message", operation: "post", select: "channel", channelId: "C123", text: "Hello"}
+```
+
+### ⚠️ Example Availability
+`includeExamples: true` returns real configurations from workflow templates.
+- Coverage varies by node popularity
+- When no examples available, use `get_node_essentials` + `validate_node_minimal`
 
 ## Validation Strategy
 
-### Before Building:
-1. validate_node_minimal() - Check required fields
-2. validate_node_operation() - Full configuration validation
-3. Fix all errors before proceeding
+### Level 1 - Quick Check (before building)
+`validate_node_minimal(nodeType, config)` - Required fields only (<100ms)
 
-### After Building:
-1. validate_workflow() - Complete workflow validation
-2. validate_workflow_connections() - Structure validation
-3. validate_workflow_expressions() - Expression syntax check
+### Level 2 - Comprehensive (before building)
+`validate_node_operation(nodeType, config, 'runtime')` - Full validation with fixes
 
-### After Deployment:
-1. n8n_validate_workflow({id}) - Validate deployed workflow
-2. n8n_list_executions() - Monitor execution status
-3. n8n_update_partial_workflow() - Fix issues using diffs
+### Level 3 - Complete (after building)
+`validate_workflow(workflow)` - Connections, expressions, AI tools
 
-## Response Structure
+### Level 4 - Post-Deployment
+1. `n8n_validate_workflow({id})` - Validate deployed workflow
+2. `n8n_autofix_workflow({id})` - Auto-fix common errors
+3. `n8n_list_executions()` - Monitor execution status
 
-1. **Discovery**: Show available nodes and options
-2. **Pre-Validation**: Validate node configurations first
-3. **Configuration**: Show only validated, working configs
-4. **Building**: Construct workflow with validated components
-5. **Workflow Validation**: Full workflow validation results
-6. **Deployment**: Deploy only after all validations pass
-7. **Post-Validation**: Verify deployment succeeded
+## Response Format
+
+### Initial Creation
+```
+[Silent tool execution in parallel]
+
+Created workflow:
+- Webhook trigger → Slack notification
+- Configured: POST /webhook → #general channel
+
+Validation: ✅ All checks passed
+```
+
+### Modifications
+```
+[Silent tool execution]
+
+Updated workflow:
+- Added error handling to HTTP node
+- Fixed required Slack parameters
+
+Changes validated successfully.
+```
+
+## Batch Operations
+
+Use `n8n_update_partial_workflow` with multiple operations in a single call:
+
+✅ GOOD - Batch multiple operations:
+```json
+n8n_update_partial_workflow({
+  id: "wf-123",
+  operations: [
+    {type: "updateNode", nodeId: "slack-1", changes: {...}},
+    {type: "updateNode", nodeId: "http-1", changes: {...}},
+    {type: "cleanStaleConnections"}
+  ]
+})
+```
+
+❌ BAD - Separate calls:
+```json
+n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
+n8n_update_partial_workflow({id: "wf-123", operations: [{...}]})
+```
 
 ## Example Workflow
 
-### Smart Template-First Approach
+### Template-First Approach
 
-#### 1. Find existing templates
-// Find simple Slack templates for marketers
-const templates = search_templates_by_metadata({
+```
+// STEP 1: Template Discovery (parallel execution)
+[Silent execution]
+search_templates_by_metadata({
   requiredService: 'slack',
   complexity: 'simple',
-  targetAudience: 'marketers',
-  maxSetupMinutes: 30
+  targetAudience: 'marketers'
 })
-
-// Or search by text
-search_templates('slack notification')
-
-// Or get curated templates
 get_templates_for_task('slack_integration')
 
-#### 2. Use and customize template
-const workflow = get_template(templates.items[0].id, {mode: 'full'})
+// STEP 2: Use template
+get_template(templateId, {mode: 'full'})
 validate_workflow(workflow)
 
-### Building from Scratch (if no suitable template)
+// Response after all tools complete:
+"Found template by **David Ashby** (@cfomodz).
+View at: https://n8n.io/workflows/2414
 
-#### 1. Discovery & Configuration
-search_nodes({query: 'slack'})
-get_node_essentials('n8n-nodes-base.slack')
+Validation: ✅ All checks passed"
+```
 
-#### 2. Pre-Validation
-validate_node_minimal('n8n-nodes-base.slack', {resource:'message', operation:'send'})
+### Building from Scratch (if no template)
+
+```
+// STEP 1: Discovery (parallel execution)
+[Silent execution]
+search_nodes({query: 'slack', includeExamples: true})
+list_nodes({category: 'communication'})
+
+// STEP 2: Configuration (parallel execution)
+[Silent execution]
+get_node_essentials('n8n-nodes-base.slack', {includeExamples: true})
+get_node_essentials('n8n-nodes-base.webhook', {includeExamples: true})
+
+// STEP 3: Validation (parallel execution)
+[Silent execution]
+validate_node_minimal('n8n-nodes-base.slack', config)
 validate_node_operation('n8n-nodes-base.slack', fullConfig, 'runtime')
 
-#### 3. Build Workflow
-// Create workflow JSON with validated configs
+// STEP 4: Build
+// Construct workflow with validated configs
+// ⚠️ Set ALL parameters explicitly
 
-#### 4. Workflow Validation
+// STEP 5: Validate
+[Silent execution]
 validate_workflow(workflowJson)
-validate_workflow_connections(workflowJson)
-validate_workflow_expressions(workflowJson)
 
-#### 5. Deploy (if configured)
-n8n_create_workflow(validatedWorkflow)
-n8n_validate_workflow({id: createdWorkflowId})
+// Response after all tools complete:
+"Created workflow: Webhook → Slack
+Validation: ✅ Passed"
+```
 
-#### 6. Update Using Diffs
+### Batch Updates
+
+```json
+// ONE call with multiple operations
 n8n_update_partial_workflow({
-  workflowId: id,
+  id: "wf-123",
   operations: [
-    {type: 'updateNode', nodeId: 'slack1', changes: {position: [100, 200]}}
+    {type: "updateNode", nodeId: "slack-1", changes: {position: [100, 200]}},
+    {type: "updateNode", nodeId: "http-1", changes: {position: [300, 200]}},
+    {type: "cleanStaleConnections"}
   ]
 })
+```
 
 ## Important Rules
 
-- ALWAYS check for existing templates before building from scratch
-- LEVERAGE metadata filters to find skill-appropriate templates
-- **ALWAYS ATTRIBUTE TEMPLATES**: When using any template, you MUST share the author's name, username, and link to the original template on n8n.io
-- VALIDATE templates before deployment (they may need updates)
-- USE diff operations for updates (80-90% token savings)
-- STATE validation results clearly
-- FIX all errors before proceeding
+### Core Behavior
+1. **Silent execution** - No commentary between tools
+2. **Parallel by default** - Execute independent operations simultaneously
+3. **Templates first** - Always check before building (2,500+ available)
+4. **Multi-level validation** - Quick check → Full validation → Workflow validation
+5. **Never trust defaults** - Explicitly configure ALL parameters
 
-## Template Discovery Tips
+### Attribution & Credits
+- **MANDATORY TEMPLATE ATTRIBUTION**: Share author name, username, and n8n.io link
+- **Template validation** - Always validate before deployment (may need updates)
 
-- **97.5% of templates have metadata** - Use smart filtering!
-- **Filter combinations work best** - Combine complexity + setup time + service
-- **Templates save 70-90% development time** - Always check first
-- **Metadata is AI-generated** - Occasionally imprecise but highly useful
-- **Use `includeMetadata: false` for fast browsing** - Add metadata only when needed
-```
+### Performance
+- **Batch operations** - Use diff operations with multiple changes in one call
+- **Parallel execution** - Search, validate, and configure simultaneously
+- **Template metadata** - Use smart filtering for faster discovery
+
+### Code Node Usage
+- **Avoid when possible** - Prefer standard nodes
+- **Only when necessary** - Use code node as last resort
+- **AI tool capability** - ANY node can be an AI tool (not just marked ones)
+````
 
 Save these instructions in your Claude Project for optimal n8n workflow assistance with intelligent template discovery.
 
@@ -540,11 +670,11 @@ This tool was created to benefit everyone in the n8n community without friction.
 ## Features
 
 - **🔍 Smart Node Search**: Find nodes by name, category, or functionality
-- **📖 Essential Properties**: Get only the 10-20 properties that matter (NEW in v2.4.0)
-- **🎯 Task Templates**: Pre-configured settings for common automation tasks
+- **📖 Essential Properties**: Get only the 10-20 properties that matter
+- **💡 Real-World Examples**: 2,646 pre-extracted configurations from popular templates
 - **✅ Config Validation**: Validate node configurations before deployment
 - **🔗 Dependency Analysis**: Understand property relationships and conditions
-- **💡 Working Examples**: Real-world examples for immediate use
+- **🎯 Template Discovery**: 2,500+ workflow templates with smart filtering
 - **⚡ Fast Response**: Average query time ~12ms with optimized SQLite
 - **🌐 Universal Compatibility**: Works with any Node.js version
 
@@ -570,8 +700,8 @@ Once connected, Claude can use these powerful tools:
 - **`tools_documentation`** - Get documentation for any MCP tool (START HERE!)
 - **`list_nodes`** - List all n8n nodes with filtering options
 - **`get_node_info`** - Get comprehensive information about a specific node
-- **`get_node_essentials`** - Get only essential properties with examples (10-20 properties instead of 200+)
-- **`search_nodes`** - Full-text search across all node documentation
+- **`get_node_essentials`** - Get only essential properties (10-20 instead of 200+). Use `includeExamples: true` to get top 3 real-world configurations from popular templates
+- **`search_nodes`** - Full-text search across all node documentation. Use `includeExamples: true` to get top 2 real-world configurations per node from templates
 - **`search_node_properties`** - Find specific properties within nodes
 - **`list_ai_tools`** - List all AI-capable nodes (ANY node can be used as AI tool!)
 - **`get_node_as_tool_info`** - Get guidance on using any node as an AI tool
@@ -585,8 +715,6 @@ Once connected, Claude can use these powerful tools:
 - **`get_templates_for_task`** - Curated templates for common automation tasks
 
 ### Advanced Tools
-- **`get_node_for_task`** - Pre-configured node settings for common tasks
-- **`list_tasks`** - Discover available task templates
 - **`validate_node_operation`** - Validate node configurations (operation-aware, profiles support)
 - **`validate_node_minimal`** - Quick validation for just required fields
 - **`validate_workflow`** - Complete workflow validation including AI tool connections
@@ -610,6 +738,7 @@ These powerful tools allow you to manage n8n workflows directly from Claude. The
 - **`n8n_delete_workflow`** - Delete workflows permanently
 - **`n8n_list_workflows`** - List workflows with filtering and pagination
 - **`n8n_validate_workflow`** - Validate workflows already in n8n by ID (NEW in v2.6.3)
+- **`n8n_autofix_workflow`** - Automatically fix common workflow errors (NEW in v2.13.0!)
 
 #### Execution Management
 - **`n8n_trigger_webhook_workflow`** - Trigger workflows via webhook URL
@@ -625,14 +754,17 @@ These powerful tools allow you to manage n8n workflows directly from Claude. The
 ### Example Usage
 
 ```typescript
-// Get essentials for quick configuration
-get_node_essentials("nodes-base.httpRequest")
+// Get essentials with real-world examples from templates
+get_node_essentials({
+  nodeType: "nodes-base.httpRequest",
+  includeExamples: true  // Returns top 3 configs from popular templates
+})
 
-// Find nodes for a specific task
-search_nodes({ query: "send email gmail" })
-
-// Get pre-configured settings
-get_node_for_task("send_email")
+// Search nodes with configuration examples
+search_nodes({
+  query: "send email gmail",
+  includeExamples: true  // Returns top 2 configs per node
+})
 
 // Validate before deployment
 validate_node_operation({
@@ -723,12 +855,14 @@ npm run dev:http       # HTTP dev mode
 
 ## 📊 Metrics & Coverage
 
-Current database coverage (n8n v1.106.3):
+Current database coverage (n8n v1.113.3):
 
-- ✅ **535/535** nodes loaded (100%)
+- ✅ **536/536** nodes loaded (100%)
 - ✅ **528** nodes with properties (98.7%)
 - ✅ **470** nodes with documentation (88%)
 - ✅ **267** AI-capable tools detected
+- ✅ **2,646** pre-extracted template configurations
+- ✅ **2,500+** workflow templates available
 - ✅ **AI Agent & LangChain nodes** fully documented
 - ⚡ **Average response time**: ~12ms
 - 💾 **Database size**: ~15MB (optimized)
@@ -768,7 +902,7 @@ docker run --rm ghcr.io/czlonkowski/n8n-mcp:latest --version
 
 ## 🧪 Testing
 
-The project includes a comprehensive test suite with **1,356 tests** ensuring code quality and reliability:
+The project includes a comprehensive test suite with **2,883 tests** ensuring code quality and reliability:
 
 ```bash
 # Run all tests
@@ -788,9 +922,9 @@ npm run test:bench          # Performance benchmarks
 
 ### Test Suite Overview
 
-- **Total Tests**: 1,356 (100% passing)
-  - **Unit Tests**: 1,107 tests across 44 files
-  - **Integration Tests**: 249 tests across 14 files
+- **Total Tests**: 2,883 (100% passing)
+  - **Unit Tests**: 2,526 tests across 99 files
+  - **Integration Tests**: 357 tests across 20 files
 - **Execution Time**: ~2.5 minutes in CI
 - **Test Framework**: Vitest (for speed and TypeScript support)
 - **Mocking**: MSW for API mocking, custom mocks for databases
@@ -804,22 +938,24 @@ npm run test:bench          # Performance benchmarks
 
 ### Testing Architecture
 
-- **Unit Tests**: Isolated component testing with mocks
-  - Services layer: ~450 tests
-  - Parsers: ~200 tests
-  - Database repositories: ~100 tests
-  - MCP tools: ~180 tests
+**Total: 3,336 tests** across unit and integration test suites
 
-- **Integration Tests**: Full system behavior validation
-  - MCP Protocol compliance: 72 tests
-  - Database operations: 89 tests
-  - Error handling: 44 tests
-  - Performance: 44 tests
+- **Unit Tests** (2,766 tests): Isolated component testing with mocks
+  - Services layer: Enhanced validation, property filtering, workflow validation
+  - Parsers: Node parsing, property extraction, documentation mapping
+  - Database: Repositories, adapters, migrations, FTS5 search
+  - MCP tools: Tool definitions, documentation system
+  - HTTP server: Multi-tenant support, security, configuration
 
-- **Benchmarks**: Performance testing for critical paths
-  - Database queries
-  - Node loading
-  - Search operations
+- **Integration Tests** (570 tests): Full system behavior validation
+  - **n8n API Integration** (172 tests): All 18 MCP handler tools tested against real n8n instance
+    - Workflow management: Create, read, update, delete, list, validate, autofix
+    - Execution management: Trigger, retrieve, list, delete
+    - System tools: Health check, tool listing, diagnostics
+  - **MCP Protocol** (119 tests): Protocol compliance, session management, error handling
+  - **Database** (226 tests): Repository operations, transactions, performance, FTS5 search
+  - **Templates** (35 tests): Template fetching, storage, metadata operations
+  - **Docker** (18 tests): Configuration, entrypoint, security validation
 
 For detailed testing documentation, see [Testing Architecture](./docs/testing-architecture.md).
 

docker-compose.yml

@@ -23,7 +23,11 @@ services:
       # Database
       NODE_DB_PATH: ${NODE_DB_PATH:-/app/data/nodes.db}
       REBUILD_ON_START: ${REBUILD_ON_START:-false}
-      
+
+      # Telemetry: Anonymous usage statistics are ENABLED by default
+      # To opt-out, uncomment and set to 'true':
+      # N8N_MCP_TELEMETRY_DISABLED: ${N8N_MCP_TELEMETRY_DISABLED:-true}
+
       # Optional: n8n API configuration (enables 16 additional management tools)
       # Uncomment and configure to enable n8n workflow management
       # N8N_API_URL: ${N8N_API_URL}

docs/CHANGELOG.md

@@ -5,7 +5,161 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [2.14.4] - 2025-09-30
+
+### Added
+- **Workflow Cleanup Operations**: Two new operations for `n8n_update_partial_workflow` to handle broken workflow recovery
+  - `cleanStaleConnections`: Automatically removes all connections referencing non-existent nodes
+    - Essential after node renames or deletions that leave dangling connection references
+    - Supports `dryRun: true` mode to preview what would be removed
+    - Removes both source and target stale connections
+  - `replaceConnections`: Replace entire connections object in a single operation
+    - Faster than crafting many individual connection operations
+    - Useful for bulk connection rewiring
+
+- **Graceful Error Handling for Connection Operations**: Enhanced `removeConnection` operation
+  - New `ignoreErrors` flag: When `true`, operation succeeds even if connection doesn't exist
+  - Perfect for cleanup scenarios where you're not sure if connections exist
+  - Maintains backwards compatibility (defaults to `false` for strict validation)
+
+- **Best-Effort Mode**: New `continueOnError` mode for `WorkflowDiffRequest`
+  - Apply valid operations even if some fail
+  - Returns detailed results with `applied` and `failed` operation indices
+  - Breaks atomic guarantees intentionally for bulk cleanup scenarios
+  - Maintains atomic mode as default for safety
+
+### Enhanced
+- **Tool Documentation**: Updated `n8n_update_partial_workflow` documentation
+  - Added examples for cleanup scenarios
+  - Documented new operation types and modes
+  - Added best practices for workflow recovery
+  - Clarified atomic vs. best-effort behavior
+
+- **Type System**: Extended workflow diff types
+  - Added `CleanStaleConnectionsOperation` interface
+  - Added `ReplaceConnectionsOperation` interface
+  - Extended `WorkflowDiffResult` with `applied`, `failed`, and `staleConnectionsRemoved` fields
+  - Updated type guards for new connection operations
+
+### Testing
+- Added comprehensive test suite for v2.14.4 features
+  - 15 new tests covering all new operations and modes
+  - Tests for cleanStaleConnections with various stale scenarios
+  - Tests for replaceConnections validation
+  - Tests for ignoreErrors flag behavior
+  - Tests for continueOnError mode with mixed success/failure
+  - Backwards compatibility verification tests
+
+### Impact
+- **Time Saved**: Reduces broken workflow fix time from 10-15 minutes to 30 seconds
+- **Token Efficiency**: `cleanStaleConnections` is 1 operation vs 10+ manual operations
+- **User Experience**: Dramatically improved workflow recovery capabilities
+- **Backwards Compatibility**: 100% - all additions are optional and default to existing behavior
+
+## [2.13.2] - 2025-01-24
+
+### Added
+- **Operation and Resource Validation with Intelligent Suggestions**: New similarity services for n8n node configuration validation
+  - `OperationSimilarityService`: Validates operations and suggests similar alternatives using Levenshtein distance and pattern matching
+  - `ResourceSimilarityService`: Validates resources with automatic plural/singular conversion and typo detection
+  - Provides "Did you mean...?" suggestions when invalid operations or resources are used
+  - Example: `operation: "listFiles"` suggests `"search"` for Google Drive nodes
+  - Example: `resource: "files"` suggests singular `"file"` with 95% confidence
+  - Confidence-based suggestions (minimum 30% threshold) with contextual fix messages
+  - Resource-aware operation filtering ensures suggestions are contextually appropriate
+  - 5-minute cache duration for performance optimization
+  - Integrated into `EnhancedConfigValidator` for seamless validation flow
+
+- **Custom Error Handling**: New `ValidationServiceError` class for better error management
+  - Proper error chaining with cause tracking
+  - Specialized factory methods for common error scenarios
+  - Type-safe error propagation throughout the validation pipeline
+
+### Enhanced
+- **Code Quality and Security Improvements** (based on code review feedback):
+  - Safe JSON parsing with try-catch error boundaries
+  - Type guards for safe property access (`getOperationValue`, `getResourceValue`)
+  - Memory leak prevention with periodic cache cleanup
+  - Performance optimization with early termination for exact matches
+  - Replaced magic numbers with named constants for better maintainability
+  - Comprehensive JSDoc documentation for all public methods
+  - Improved confidence calculation for typos and transpositions
+
+### Fixed
+- **Test Compatibility**: Updated test expectations to correctly handle exact match scenarios
+- **Cache Management**: Fixed cache cleanup to prevent unbounded memory growth
+- **Validation Deduplication**: Enhanced config validator now properly replaces base validator errors with detailed suggestions
+
+### Testing
+- Added comprehensive test coverage for similarity services (37 new tests)
+- All unit tests passing with proper edge case handling
+- Integration confirmed via n8n-mcp-tester agent validation
+
+## [2.13.1] - 2025-01-24
+
+### Changed
+- **Removed 5-operation limit from n8n_update_partial_workflow**: The workflow diff engine now supports unlimited operations per request
+  - Previously limited to 5 operations for "transactional integrity"
+  - Analysis revealed the limit was unnecessary - the clone-validate-apply pattern already ensures atomicity
+  - All operations are validated before any are applied, maintaining data integrity
+  - Enables complex workflow refactoring in single API calls
+  - Updated documentation and examples to demonstrate large batch operations (26+ operations)
+
+## [2.13.0] - 2025-01-24
+
+### Added
+- **Webhook Path Autofixer**: Automatically generates UUIDs for webhook nodes missing path configuration
+  - Generates unique UUID for both `path` parameter and `webhookId` field
+  - Conditionally updates typeVersion to 2.1 only when < 2.1 to ensure compatibility
+  - High confidence fix (95%) as UUID generation is deterministic
+  - Resolves webhook nodes showing "?" in the n8n UI
+
+- **Enhanced Node Type Suggestions**: Intelligent node type correction with similarity matching
+  - Multi-factor scoring system: name similarity, category match, package match, pattern match
+  - Handles deprecated package prefixes (n8n-nodes-base. → nodes-base.)
+  - Corrects capitalization mistakes (HttpRequest → httpRequest)
+  - Suggests correct packages (nodes-base.openai → nodes-langchain.openAi)
+  - Only auto-fixes suggestions with ≥90% confidence
+  - 5-minute cache for performance optimization
+
+- **n8n_autofix_workflow Tool**: New MCP tool for automatic workflow error correction
+  - Comprehensive documentation with examples and best practices
+  - Supports 5 fix types: expression-format, typeversion-correction, error-output-config, node-type-correction, webhook-missing-path
+  - Confidence-based system (high/medium/low) for safe fixes
+  - Preview mode to review changes before applying
+  - Integrated with workflow validation pipeline
+
+### Fixed
+- **Security**: Eliminated ReDoS vulnerability in NodeSimilarityService
+  - Replaced all regex patterns with string-based matching
+  - No performance impact while maintaining accuracy
+
+- **Performance**: Optimized similarity matching algorithms
+  - Levenshtein distance algorithm optimized from O(m*n) space to O(n)
+  - Added early termination for performance improvement
+  - Cache invalidation with version tracking prevents memory leaks
+
+- **Code Quality**: Improved maintainability and type safety
+  - Extracted magic numbers into named constants
+  - Added proper type guards for runtime safety
+  - Created centralized node-type-utils for consistent type normalization
+  - Fixed silent failures in setNestedValue operations
+
+### Changed
+- Template sanitizer now includes defensive null checks for runtime safety
+- Workflow validator uses centralized type normalization utility
+
+## [2.12.2] - 2025-01-22
+
+### Changed
+- Updated n8n dependencies to latest versions:
+  - n8n: 1.111.0 → 1.112.3
+  - n8n-core: 1.110.0 → 1.111.0
+  - n8n-workflow: 1.108.0 → 1.109.0
+  - @n8n/n8n-nodes-langchain: 1.110.0 → 1.111.1
+- Rebuilt node database with 536 nodes (438 from n8n-nodes-base, 98 from langchain)
+
+## [2.12.1] - 2025-01-21
 
 ### Added
 - **Comprehensive Expression Format Validation System**: Three-tier validation strategy for n8n expressions

docs/CODEX_SETUP.md

@@ -0,0 +1,34 @@
+# Codex Setup
+
+Connect n8n-MCP to Codex for enhanced n8n workflow development.
+
+## Update your Codex configuration
+
+Go to your Codex settings at `~/.codex/config.toml` and add the following configuration:
+
+### Basic configuration (documentation tools only):
+```toml
+[mcp_servers.n8n]
+command = "npx"
+args = ["n8n-mcp"]
+env = { "MCP_MODE" = "stdio", "LOG_LEVEL" = "error", "DISABLE_CONSOLE_OUTPUT" = "true" }
+```
+
+### Full configuration (with n8n management tools):
+```toml
+[mcp_servers.n8n]
+command = "npx"
+args = ["n8n-mcp"]
+env = { "MCP_MODE" = "stdio", "LOG_LEVEL" = "error", "DISABLE_CONSOLE_OUTPUT" = "true", "N8N_API_URL" = "https://your-n8n-instance.com", "N8N_API_KEY" = "your-api-key" }
+```
+
+Make sure to replace `https://your-n8n-instance.com` with your actual n8n URL and `your-api-key` with your n8n API key.
+
+## Managing Your MCP Server
+Enter the Codex CLI and use the `/mcp` command to see server status and available tools.
+
+![n8n-MCP connected and showing 39 tools available](./img/codex_connected.png)
+
+## Project Instructions
+
+For optimal results, create a `AGENTS.md` file in your project root with the instructions same with [main README's Claude Project Setup section](../README.md#-claude-project-setup).

docs/local/DEEP_DIVE_ANALYSIS_README.md

@@ -0,0 +1,225 @@
+# N8N-MCP Deep Dive Analysis - October 2, 2025
+
+## Overview
+
+This directory contains a comprehensive deep-dive analysis of n8n-mcp usage data from September 26 - October 2, 2025.
+
+**Data Volume Analyzed:**
+- 212,375 telemetry events
+- 5,751 workflow creations
+- 2,119 unique users
+- 6 days of usage data
+
+## Report Structure
+
+
+###: `DEEP_DIVE_ANALYSIS_2025-10-02.md` (Main Report)
+
+**Sections Covered:**
+1. **Executive Summary** - Key findings and recommendations
+2. **Tool Performance Analysis** - Success rates, performance metrics, critical findings
+3. **Validation Catastrophe** - The node type prefix disaster analysis
+4. **Usage Patterns & User Segmentation** - User distribution, daily trends
+5. **Tool Sequence Analysis** - How AI agents use tools together
+6. **Workflow Creation Patterns** - Complexity distribution, popular nodes
+7. **Platform & Version Distribution** - OS, architecture, version adoption
+8. **Error Patterns & Root Causes** - TypeErrors, validation errors, discovery failures
+9. **P0-P1 Refactoring Recommendations** - Detailed implementation guides
+
+**Sections Covered:**
+- Remaining P1 and P2 recommendations
+- Architectural refactoring suggestions
+- Telemetry enhancements
+- CHANGELOG integration
+- Final recommendations summary
+
+## Key Findings Summary
+
+### Critical Issues (P0 - Fix Immediately)
+
+1. **Node Type Prefix Validation Catastrophe**
+   - 5,000+ validation errors from single root cause
+   - `nodes-base.X` vs `n8n-nodes-base.X` confusion
+   - **Solution**: Auto-normalize prefixes (2-4 hours effort)
+
+2. **TypeError in Node Information Tools**
+   - 10-18% failure rate in get_node_essentials/info
+   - 1,000+ failures affecting hundreds of users
+   - **Solution**: Complete null-safety audit (1 day effort)
+
+3. **Task Discovery Failures**
+   - `get_node_for_task` failing 28% of the time
+   - Worst-performing tool in entire system
+   - **Solution**: Expand task library + fuzzy matching (3 days effort)
+
+### Performance Metrics
+
+**Excellent Reliability (96-100% success):**
+- n8n_update_partial_workflow: 98.7%
+- search_nodes: 99.8%
+- n8n_create_workflow: 96.1%
+- All workflow management tools: 100%
+
+**User Distribution:**
+- Power Users (12): 2,112 events/user, 33 workflows
+- Heavy Users (47): 673 events/user, 18 workflows
+- Regular Users (516): 199 events/user, 7 workflows (CORE AUDIENCE)
+- Active Users (919): 52 events/user, 2 workflows
+- Casual Users (625): 8 events/user, 1 workflow
+
+### Usage Insights
+
+**Most Used Tools:**
+1. n8n_update_partial_workflow: 10,177 calls (iterative refinement)
+2. search_nodes: 8,839 calls (node discovery)
+3. n8n_create_workflow: 6,046 calls (workflow creation)
+
+**Most Common Tool Sequences:**
+1. update → update → update (549x) - Iterative refinement pattern
+2. create → update (297x) - Create then refine
+3. update → get_workflow (265x) - Update then verify
+
+**Most Popular Nodes:**
+1. code (53% of workflows) - AI agents love programmatic control
+2. httpRequest (47%) - Integration-heavy usage
+3. webhook (32%) - Event-driven automation
+
+## SQL Analytical Views Created
+
+15 comprehensive views were created in Supabase for ongoing analysis:
+
+1. `vw_tool_performance` - Performance metrics per tool
+2. `vw_error_analysis` - Error patterns and frequencies
+3. `vw_validation_analysis` - Validation failure details
+4. `vw_tool_sequences` - Tool-to-tool transition patterns
+5. `vw_workflow_creation_patterns` - Workflow characteristics
+6. `vw_node_usage_analysis` - Node popularity and complexity
+7. `vw_node_cooccurrence` - Which nodes are used together
+8. `vw_user_activity` - Per-user activity metrics
+9. `vw_session_analysis` - Platform/version distribution
+10. `vw_workflow_validation_failures` - Workflow validation issues
+11. `vw_temporal_patterns` - Time-based usage patterns
+12. `vw_tool_funnel` - User progression through tools
+13. `vw_search_analysis` - Search behavior
+14. `vw_tool_success_summary` - Success/failure rates
+15. `vw_user_journeys` - Complete user session reconstruction
+
+## Priority Recommendations
+
+### Immediate Actions (This Week)
+
+✅ **P0-R1**: Auto-normalize node type prefixes → Eliminate 4,800 errors
+✅ **P0-R2**: Complete null-safety audit → Fix 10-18% TypeError failures
+✅ **P0-R3**: Expand get_node_for_task library → 72% → 95% success rate
+
+**Expected Impact**: Reduce error rate from 5-10% to <2% overall
+
+### Next Release (2-3 Weeks)
+
+✅ **P1-R4**: Batch workflow operations → Save 30-50% tokens
+✅ **P1-R5**: Proactive node suggestions → Reduce search iterations
+✅ **P1-R6**: Auto-fix suggestions in errors → Self-service recovery
+
+**Expected Impact**: 40% faster workflow creation, better UX
+
+### Future Roadmap (1-3 Months)
+
+✅ **A1**: Service layer consolidation → Cleaner architecture
+✅ **A2**: Repository caching → 50% faster node operations
+✅ **R10**: Workflow template library from usage → 80% coverage
+✅ **T1-T3**: Enhanced telemetry → Better observability
+
+**Expected Impact**: Scalable foundation for 10x growth
+
+## Methodology
+
+### Data Sources
+
+1. **Supabase Telemetry Database**
+   - `telemetry_events` table: 212,375 rows
+   - `telemetry_workflows` table: 5,751 rows
+
+2. **Analytical Views**
+   - Created 15 SQL views for multi-dimensional analysis
+   - Enabled complex queries and pattern recognition
+
+3. **CHANGELOG Review**
+   - Analyzed recent changes (v2.14.0 - v2.14.6)
+   - Correlated fixes with error patterns
+
+### Analysis Approach
+
+1. **Quantitative Analysis**
+   - Success/failure rates per tool
+   - Performance metrics (avg, median, p95, p99)
+   - User segmentation and cohort analysis
+   - Temporal trends and growth patterns
+
+2. **Pattern Recognition**
+   - Tool sequence analysis (Markov chains)
+   - Node co-occurrence patterns
+   - Workflow complexity distribution
+   - Error clustering and root cause analysis
+
+3. **Qualitative Insights**
+   - CHANGELOG integration
+   - Error message analysis
+   - User journey reconstruction
+   - Best practice identification
+
+## How to Use This Analysis
+
+### For Development Priorities
+
+1. Review **P0 Critical Recommendations** (Section 8)
+2. Check estimated effort and impact
+3. Prioritize based on ROI (impact/effort ratio)
+4. Follow implementation guides with code examples
+
+### For Architecture Decisions
+
+1. Review **Architectural Recommendations** (Section 9)
+2. Consider service layer consolidation
+3. Evaluate repository caching opportunities
+4. Plan for 10x scale
+
+### For Product Strategy
+
+1. Review **Usage Patterns** (Section 3 & 5)
+2. Understand user segments (power vs casual)
+3. Identify high-value features (most-used tools)
+4. Focus on reliability over features (96% success rate target)
+
+### For Telemetry Enhancement
+
+1. Review **Telemetry Enhancements** (Section 10)
+2. Add fine-grained timing metrics
+3. Track workflow creation funnels
+4. Monitor node-level analytics
+
+## Contact & Feedback
+
+For questions about this analysis or to request additional insights:
+- Data Analyst: Claude Code with Supabase MCP
+- Analysis Date: October 2, 2025
+- Data Period: September 26 - October 2, 2025
+
+## Change Log
+
+- **2025-10-02**: Initial comprehensive analysis completed
+  - 15 SQL analytical views created
+  - 13 sections of detailed findings
+  - P0/P1/P2 recommendations with implementation guides
+  - Code examples and effort estimates provided
+
+## Next Steps
+
+1. ✅ Review findings with development team
+2. ✅ Prioritize P0 recommendations for immediate implementation
+3. ✅ Plan P1 features for next release cycle
+4. ✅ Set up monitoring for key metrics
+5. ✅ Schedule follow-up analysis (weekly recommended)
+
+---
+
+*This analysis represents a snapshot of n8n-mcp usage during early adoption phase. Patterns may evolve as the user base grows and matures.*

docs/local/TEMPLATE_MINING_ANALYSIS.md

@@ -0,0 +1,369 @@
+# Template Mining Analysis - Alternative to P0-R3
+
+**Date**: 2025-10-02
+**Context**: Analyzing whether to fix `get_node_for_task` (28% failure rate) or replace it with template-based configuration extraction
+
+## Executive Summary
+
+**RECOMMENDATION**: Replace `get_node_for_task` with template-based configuration extraction. The template database contains 2,646 real-world workflows with rich node configurations that far exceed the 31 hardcoded task templates.
+
+## Key Findings
+
+### 1. Template Database Coverage
+
+- **Total Templates**: 2,646 production workflows from n8n.io
+- **Unique Node Types**: 543 (covers 103% of our 525 core nodes)
+- **Metadata Coverage**: 100% (AI-generated structured metadata)
+
+### 2. Node Type Coverage in Templates
+
+Top node types by template usage:
+```
+3,820 templates: n8n-nodes-base.httpRequest      (144% of total templates!)
+3,678 templates: n8n-nodes-base.set
+2,445 templates: n8n-nodes-base.code
+1,700 templates: n8n-nodes-base.googleSheets
+1,471 templates: @n8n/n8n-nodes-langchain.agent
+1,269 templates: @n8n/n8n-nodes-langchain.lmChatOpenAi
+  792 templates: n8n-nodes-base.telegram
+  702 templates: n8n-nodes-base.httpRequestTool
+  596 templates: n8n-nodes-base.gmail
+  466 templates: n8n-nodes-base.webhook
+```
+
+**Comparison**:
+- Hardcoded task templates: 31 tasks covering 5.9% of nodes
+- Real templates: 2,646 templates with 2-3k examples for common nodes
+
+### 3. Database Structure
+
+```sql
+CREATE TABLE templates (
+  id INTEGER PRIMARY KEY,
+  workflow_id INTEGER UNIQUE NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  -- Node information
+  nodes_used TEXT,              -- JSON array: ["n8n-nodes-base.httpRequest", ...]
+  workflow_json_compressed TEXT, -- Base64 encoded gzip of full workflow
+  -- Metadata (100% coverage)
+  metadata_json TEXT,           -- AI-generated structured metadata
+  -- Stats
+  views INTEGER DEFAULT 0,
+  created_at DATETIME,
+  -- ...
+);
+```
+
+### 4. Real Configuration Examples
+
+#### HTTP Request Node Configurations
+
+**Simple URL fetch**:
+```json
+{
+  "url": "https://api.example.com/data",
+  "options": {}
+}
+```
+
+**With authentication**:
+```json
+{
+  "url": "=https://api.wavespeed.ai/api/v3/predictions/{{ $json.data.id }}/result",
+  "options": {},
+  "authentication": "genericCredentialType",
+  "genericAuthType": "httpHeaderAuth"
+}
+```
+
+**Complex expressions**:
+```json
+{
+  "url": "=https://image.pollinations.ai/prompt/{{$('Social Media Content Factory').item.json.output.description.replaceAll(' ','-').replaceAll(',','').replaceAll('.','') }}",
+  "options": {}
+}
+```
+
+#### Webhook Node Configurations
+
+**Basic webhook**:
+```json
+{
+  "path": "ytube",
+  "options": {},
+  "httpMethod": "POST",
+  "responseMode": "responseNode"
+}
+```
+
+**With binary data**:
+```json
+{
+  "path": "your-endpoint",
+  "options": {
+    "binaryPropertyName": "data"
+  },
+  "httpMethod": "POST"
+}
+```
+
+### 5. AI-Generated Metadata
+
+Each template has structured metadata including:
+
+```json
+{
+  "categories": ["automation", "integration", "data processing"],
+  "complexity": "medium",
+  "use_cases": [
+    "Extract transaction data from Gmail",
+    "Automate bookkeeping",
+    "Expense tracking"
+  ],
+  "estimated_setup_minutes": 30,
+  "required_services": ["Gmail", "Google Sheets", "Google Gemini"],
+  "key_features": [
+    "Fetch emails by label",
+    "Extract transaction data",
+    "Use LLM for structured output"
+  ],
+  "target_audience": ["Accountants", "Small business owners"]
+}
+```
+
+## Comparison: Task Templates vs Real Templates
+
+### Current Approach (get_node_for_task)
+
+**Pros**:
+- Curated configurations with best practices
+- Predictable, stable responses
+- Fast lookup (no decompression needed)
+
+**Cons**:
+- Only 31 tasks (5.9% node coverage)
+- 28% failure rate (users can't find what they need)
+- Requires manual maintenance
+- Static configurations without real-world context
+- Usage ratio 22.5:1 (search_nodes is preferred)
+
+### Template-Based Approach
+
+**Pros**:
+- 2,646 real workflows with 2-3k examples for common nodes
+- 100% metadata coverage for semantic matching
+- Real-world patterns and best practices
+- Covers 543 node types (103% coverage)
+- Self-updating (templates fetched from n8n.io)
+- Rich context (use cases, complexity, setup time)
+
+**Cons**:
+- Requires decompression for full workflow access
+- May contain template-specific context (but can be filtered)
+- Need ranking/filtering logic for best matches
+
+## Proposed Implementation Strategy
+
+### Phase 1: Extract Node Configurations from Templates
+
+Create a new service: `TemplateConfigExtractor`
+
+```typescript
+interface ExtractedNodeConfig {
+  nodeType: string;
+  configuration: Record<string, any>;
+  source: {
+    templateId: number;
+    templateName: string;
+    templateViews: number;
+    useCases: string[];
+    complexity: 'simple' | 'medium' | 'complex';
+  };
+  patterns: {
+    hasAuthentication: boolean;
+    hasExpressions: boolean;
+    hasOptionalFields: boolean;
+  };
+}
+
+class TemplateConfigExtractor {
+  async extractConfigsForNode(
+    nodeType: string,
+    options?: {
+      complexity?: 'simple' | 'medium' | 'complex';
+      requiresAuth?: boolean;
+      limit?: number;
+    }
+  ): Promise<ExtractedNodeConfig[]> {
+    // 1. Query templates containing nodeType
+    // 2. Decompress workflow_json_compressed
+    // 3. Extract node configurations
+    // 4. Rank by popularity + complexity match
+    // 5. Return top N configurations
+  }
+}
+```
+
+### Phase 2: Integrate with Existing Tools
+
+**Option A**: Enhance `get_node_essentials`
+- Add `includeExamples: boolean` parameter
+- Return 2-3 real configurations from templates
+- Preserve existing compact format
+
+**Option B**: Enhance `get_node_info`
+- Add `examples` section with template-sourced configs
+- Include source attribution (template name, views)
+
+**Option C**: New tool `get_node_examples`
+- Dedicated tool for retrieving configuration examples
+- Query by node type, complexity, use case
+- Returns ranked list of real configurations
+
+### Phase 3: Deprecate get_node_for_task
+
+- Mark as deprecated in tool documentation
+- Redirect to enhanced tools
+- Remove after 2-3 version cycles
+
+## Performance Considerations
+
+### Decompression Cost
+
+- Average compressed size: 6-12 KB
+- Decompression time: ~5-10ms per template
+- Caching strategy needed for frequently accessed templates
+
+### Query Strategy
+
+```sql
+-- Fast: Get templates for a node type (no decompression)
+SELECT id, name, views, metadata_json
+FROM templates
+WHERE nodes_used LIKE '%n8n-nodes-base.httpRequest%'
+ORDER BY views DESC
+LIMIT 10;
+
+-- Then decompress only top matches
+```
+
+### Caching
+
+- Cache decompressed workflows for popular templates (top 100)
+- TTL: 1 hour
+- Estimated memory: 100 * 50KB = 5MB
+
+## Impact on P0-R3
+
+**Original P0-R3 Plan**: Expand task library from 31 to 100+ tasks using fuzzy matching
+
+**New Approach**: Mine 2,646 templates for real configurations
+
+**Impact Assessment**:
+
+| Metric | Original Plan | Template Mining |
+|--------|--------------|-----------------|
+| Configuration examples | 100 (estimated) | 2,646+ actual |
+| Node coverage | ~20% | 103% |
+| Maintenance | High (manual) | Low (auto-fetch) |
+| Accuracy | Curated | Production-tested |
+| Context richness | Limited | Rich metadata |
+| Development time | 2-3 weeks | 1 week |
+
+**Recommendation**: PIVOT to template mining approach for P0-R3
+
+## Implementation Estimate
+
+### Week 1: Core Infrastructure
+- Day 1-2: Create `TemplateConfigExtractor` service
+- Day 3: Implement caching layer
+- Day 4-5: Testing and optimization
+
+### Week 2: Integration
+- Day 1-2: Enhance `get_node_essentials` with examples
+- Day 3: Update tool documentation
+- Day 4-5: Integration testing
+
+**Total**: 2 weeks vs 3 weeks for original plan
+
+## Validation Tests
+
+```typescript
+// Test: Extract HTTP Request configs
+const configs = await extractor.extractConfigsForNode(
+  'n8n-nodes-base.httpRequest',
+  { complexity: 'simple', limit: 5 }
+);
+
+// Expected: 5 configs from top templates
+// - Simple URL fetch
+// - With authentication
+// - With custom headers
+// - With expressions
+// - With error handling
+
+// Test: Extract webhook configs
+const webhookConfigs = await extractor.extractConfigsForNode(
+  'n8n-nodes-base.webhook',
+  { limit: 3 }
+);
+
+// Expected: 3 configs showing different patterns
+// - Basic POST webhook
+// - With response node
+// - With binary data handling
+```
+
+## Risks and Mitigation
+
+### Risk 1: Template Quality Varies
+- **Mitigation**: Filter by views (popularity) and metadata complexity rating
+- Only use templates with >1000 views for examples
+
+### Risk 2: Decompression Performance
+- **Mitigation**: Cache decompressed popular templates
+- Implement lazy loading (decompress on demand)
+
+### Risk 3: Template-Specific Context
+- **Mitigation**: Extract only node configuration, strip workflow-specific context
+- Provide source attribution for context
+
+### Risk 4: Breaking Changes in Template Structure
+- **Mitigation**: Robust error handling in decompression
+- Fallback to cached configs if template fetch fails
+
+## Success Metrics
+
+**Before** (get_node_for_task):
+- 392 calls, 72% success rate
+- 28% failure rate
+- 31 task templates
+- 5.9% node coverage
+
+**Target** (template-based):
+- 90%+ success rate for configuration discovery
+- 100%+ node coverage
+- 2,646+ real-world examples
+- Self-updating from n8n.io
+
+## Next Steps
+
+1. ✅ Complete template database analysis
+2. ⏳ Create `TemplateConfigExtractor` service
+3. ⏳ Implement caching layer
+4. ⏳ Enhance `get_node_essentials` with examples
+5. ⏳ Update P0 implementation plan
+6. ⏳ Begin implementation
+
+## Conclusion
+
+The template database provides a vastly superior alternative to hardcoded task templates:
+
+- **2,646 templates** vs 31 tasks (85x more examples)
+- **103% node coverage** vs 5.9% coverage (17x improvement)
+- **Real-world configurations** vs synthetic examples
+- **Self-updating** vs manual maintenance
+- **Rich metadata** for semantic matching
+
+**Recommendation**: Pivot P0-R3 from "expand task library" to "mine template configurations"

docs/local/integration-tests-phase1-summary.md

@@ -0,0 +1,260 @@
+# Integration Tests Phase 1: Foundation - COMPLETED
+
+## Overview
+Phase 1 establishes the foundation for n8n API integration testing. All core utilities, fixtures, and infrastructure are now in place.
+
+## Branch
+`feat/integration-tests-foundation`
+
+## Completed Tasks
+
+### 1. Environment Configuration
+- ✅ Updated `.env.example` with integration testing configuration
+- ✅ Added environment variables for:
+  - n8n API credentials (`N8N_API_URL`, `N8N_API_KEY`)
+  - Webhook workflow IDs (4 workflows for GET/POST/PUT/DELETE)
+  - Test configuration (cleanup, tags, naming)
+- ✅ Included detailed setup instructions in comments
+
+### 2. Directory Structure
+```
+tests/integration/n8n-api/
+├── workflows/        (empty - for Phase 2+)
+├── executions/       (empty - for Phase 2+)
+├── system/           (empty - for Phase 2+)
+├── scripts/
+│   └── cleanup-orphans.ts
+└── utils/
+    ├── credentials.ts
+    ├── n8n-client.ts
+    ├── test-context.ts
+    ├── cleanup-helpers.ts
+    ├── fixtures.ts
+    ├── factories.ts
+    └── webhook-workflows.ts
+```
+
+### 3. Core Utilities
+
+#### `credentials.ts` (200 lines)
+- Environment-aware credential loading
+- Detects CI vs local environment automatically
+- Validation functions with helpful error messages
+- Non-throwing credential check functions
+
+**Key Functions:**
+- `getN8nCredentials()` - Load credentials from .env or GitHub secrets
+- `validateCredentials()` - Ensure required credentials are present
+- `validateWebhookWorkflows()` - Check webhook workflow IDs with setup instructions
+- `hasCredentials()` - Non-throwing credential check
+- `hasWebhookWorkflows()` - Non-throwing webhook check
+
+#### `n8n-client.ts` (45 lines)
+- Singleton n8n API client wrapper
+- Pre-configured with test credentials
+- Health check functionality
+
+**Key Functions:**
+- `getTestN8nClient()` - Get/create configured API client
+- `resetTestN8nClient()` - Reset client instance
+- `isN8nApiAccessible()` - Check API connectivity
+
+#### `test-context.ts` (120 lines)
+- Resource tracking for automatic cleanup
+- Test workflow naming utilities
+- Tag management
+
+**Key Functions:**
+- `createTestContext()` - Create context for tracking resources
+- `TestContext.trackWorkflow()` - Track workflow for cleanup
+- `TestContext.trackExecution()` - Track execution for cleanup
+- `TestContext.cleanup()` - Delete all tracked resources
+- `createTestWorkflowName()` - Generate unique workflow names
+- `getTestTag()` - Get configured test tag
+
+#### `cleanup-helpers.ts` (275 lines)
+- Multi-level cleanup strategies
+- Orphaned resource detection
+- Age-based execution cleanup
+- Tag-based workflow cleanup
+
+**Key Functions:**
+- `cleanupOrphanedWorkflows()` - Find and delete test workflows
+- `cleanupOldExecutions()` - Delete executions older than X hours
+- `cleanupAllTestResources()` - Comprehensive cleanup
+- `cleanupWorkflowsByTag()` - Delete workflows by tag
+- `cleanupExecutionsByWorkflow()` - Delete workflow's executions
+
+#### `fixtures.ts` (310 lines)
+- Pre-built workflow templates
+- All using FULL node type format (n8n-nodes-base.*)
+
+**Available Fixtures:**
+- `SIMPLE_WEBHOOK_WORKFLOW` - Single webhook node
+- `SIMPLE_HTTP_WORKFLOW` - Webhook + HTTP Request
+- `MULTI_NODE_WORKFLOW` - Complex branching workflow
+- `ERROR_HANDLING_WORKFLOW` - Error output configuration
+- `AI_AGENT_WORKFLOW` - Langchain agent node
+- `EXPRESSION_WORKFLOW` - n8n expressions testing
+
+**Helper Functions:**
+- `getFixture()` - Get fixture by name (with deep clone)
+- `createCustomWorkflow()` - Build custom workflow from nodes
+
+#### `factories.ts` (315 lines)
+- Dynamic test data generation
+- Node builders with sensible defaults
+- Workflow composition helpers
+
+**Node Factories:**
+- `createWebhookNode()` - Webhook node with customization
+- `createHttpRequestNode()` - HTTP Request node
+- `createSetNode()` - Set node with assignments
+- `createManualTriggerNode()` - Manual trigger node
+
+**Connection Factories:**
+- `createConnection()` - Simple node connection
+- `createSequentialWorkflow()` - Auto-connected sequential nodes
+- `createParallelWorkflow()` - Trigger with parallel branches
+- `createErrorHandlingWorkflow()` - Workflow with error handling
+
+**Utilities:**
+- `randomString()` - Generate random test data
+- `uniqueId()` - Unique IDs for testing
+- `createTestTags()` - Test workflow tags
+- `createWorkflowSettings()` - Common settings
+
+#### `webhook-workflows.ts` (215 lines)
+- Webhook workflow configuration templates
+- Setup instructions generator
+- URL generation utilities
+
+**Key Features:**
+- `WEBHOOK_WORKFLOW_CONFIGS` - Configurations for all 4 HTTP methods
+- `printSetupInstructions()` - Print detailed setup guide
+- `generateWebhookWorkflowJson()` - Generate workflow JSON
+- `exportAllWebhookWorkflows()` - Export all 4 configs
+- `getWebhookUrl()` - Get webhook URL for testing
+- `isValidWebhookWorkflow()` - Validate workflow structure
+
+### 4. Scripts
+
+#### `cleanup-orphans.ts` (40 lines)
+- Standalone cleanup script
+- Can be run manually or in CI
+- Comprehensive output logging
+
+**Usage:**
+```bash
+npm run test:cleanup:orphans
+```
+
+### 5. npm Scripts
+Added to `package.json`:
+```json
+{
+  "test:integration:n8n": "vitest run tests/integration/n8n-api",
+  "test:cleanup:orphans": "tsx tests/integration/n8n-api/scripts/cleanup-orphans.ts"
+}
+```
+
+## Code Quality
+
+### TypeScript
+- ✅ All code passes `npm run typecheck`
+- ✅ All code compiles with `npm run build`
+- ✅ No TypeScript errors
+- ✅ Proper type annotations throughout
+
+### Error Handling
+- ✅ Comprehensive error messages
+- ✅ Helpful setup instructions in error messages
+- ✅ Non-throwing validation functions where appropriate
+- ✅ Graceful handling of missing credentials
+
+### Documentation
+- ✅ All functions have JSDoc comments
+- ✅ Usage examples in comments
+- ✅ Clear parameter descriptions
+- ✅ Return type documentation
+
+## Files Created
+
+### Documentation
+1. `docs/local/integration-testing-plan.md` (550 lines)
+2. `docs/local/integration-tests-phase1-summary.md` (this file)
+
+### Code
+1. `.env.example` - Updated with test configuration (32 new lines)
+2. `package.json` - Added 2 npm scripts
+3. `tests/integration/n8n-api/utils/credentials.ts` (200 lines)
+4. `tests/integration/n8n-api/utils/n8n-client.ts` (45 lines)
+5. `tests/integration/n8n-api/utils/test-context.ts` (120 lines)
+6. `tests/integration/n8n-api/utils/cleanup-helpers.ts` (275 lines)
+7. `tests/integration/n8n-api/utils/fixtures.ts` (310 lines)
+8. `tests/integration/n8n-api/utils/factories.ts` (315 lines)
+9. `tests/integration/n8n-api/utils/webhook-workflows.ts` (215 lines)
+10. `tests/integration/n8n-api/scripts/cleanup-orphans.ts` (40 lines)
+
+**Total New Code:** ~1,520 lines of production-ready TypeScript
+
+## Next Steps (Phase 2)
+
+Phase 2 will implement the first actual integration tests:
+- Create workflow creation tests (10+ scenarios)
+- Test P0 bug fix (SHORT vs FULL node types)
+- Test workflow retrieval
+- Test workflow deletion
+
+**Branch:** `feat/integration-tests-workflow-creation`
+
+## Prerequisites for Running Tests
+
+Before running integration tests, you need to:
+
+1. **Set up n8n instance:**
+   - Local: `npx n8n start`
+   - Or use cloud/self-hosted n8n
+
+2. **Configure credentials in `.env`:**
+   ```bash
+   N8N_API_URL=http://localhost:5678
+   N8N_API_KEY=<your-api-key>
+   ```
+
+3. **Create 4 webhook workflows manually:**
+   - One for each HTTP method (GET, POST, PUT, DELETE)
+   - Activate each workflow in n8n UI
+   - Set workflow IDs in `.env`:
+     ```bash
+     N8N_TEST_WEBHOOK_GET_ID=<workflow-id>
+     N8N_TEST_WEBHOOK_POST_ID=<workflow-id>
+     N8N_TEST_WEBHOOK_PUT_ID=<workflow-id>
+     N8N_TEST_WEBHOOK_DELETE_ID=<workflow-id>
+     ```
+
+See `docs/local/integration-testing-plan.md` for detailed setup instructions.
+
+## Success Metrics
+
+Phase 1 Success Criteria - ALL MET:
+- ✅ All utilities implemented and tested
+- ✅ TypeScript compiles without errors
+- ✅ Code follows project conventions
+- ✅ Comprehensive documentation
+- ✅ Environment configuration complete
+- ✅ Cleanup infrastructure in place
+- ✅ Ready for Phase 2 test implementation
+
+## Lessons Learned
+
+1. **N8nApiClient Constructor:** Uses config object, not separate parameters
+2. **Cursor Handling:** n8n API returns `null` for no more pages, need to convert to `undefined`
+3. **Workflow ID Validation:** Some workflows might have undefined IDs, need null checks
+4. **Connection Types:** Error connections need explicit typing to avoid TypeScript errors
+5. **Webhook Activation:** Cannot be done via API, must be manual - hence pre-activated workflow requirement
+
+## Time Invested
+
+Phase 1 actual time: ~2 hours (estimated 2-3 days in plan)
+- Faster than expected due to clear architecture and reusable patterns

docs/testing-architecture.md

@@ -2,21 +2,27 @@
 
 ## Overview
 
-This document describes the comprehensive testing infrastructure implemented for the n8n-MCP project. The testing suite includes over 1,100 tests split between unit and integration tests, benchmarks, and a complete CI/CD pipeline ensuring code quality and reliability.
+This document describes the comprehensive testing infrastructure implemented for the n8n-MCP project. The testing suite includes 3,336 tests split between unit and integration tests, benchmarks, and a complete CI/CD pipeline ensuring code quality and reliability.
 
-### Test Suite Statistics (from CI Run #41)
+### Test Suite Statistics (October 2025)
 
-- **Total Tests**: 1,182 tests
-  - **Unit Tests**: 933 tests (932 passed, 1 skipped)
-  - **Integration Tests**: 249 tests (245 passed, 4 skipped)
-- **Test Files**: 
-  - 30 unit test files
-  - 14 integration test files
-- **Test Execution Time**: 
+- **Total Tests**: 3,336 tests
+  - **Unit Tests**: 2,766 tests - Isolated component testing with mocks
+  - **Integration Tests**: 570 tests - Full system behavior validation
+    - n8n API Integration: 172 tests (all 18 MCP handler tools)
+    - MCP Protocol: 119 tests (protocol compliance, session management)
+    - Database: 226 tests (repository operations, transactions, FTS5)
+    - Templates: 35 tests (fetching, storage, metadata)
+    - Docker: 18 tests (configuration, security)
+- **Test Files**:
+  - 106 unit test files
+  - 41 integration test files
+  - Total: 147 test files
+- **Test Execution Time**:
   - Unit tests: ~2 minutes with coverage
-  - Integration tests: ~23 seconds
-  - Total CI time: ~2.5 minutes
-- **Success Rate**: 99.5% (only 5 tests skipped, 0 failures)
+  - Integration tests: ~30 seconds
+  - Total CI time: ~3 minutes
+- **Success Rate**: 100% (all tests passing in CI)
 - **CI/CD Pipeline**: Fully automated with GitHub Actions
 - **Test Artifacts**: JUnit XML, coverage reports, benchmark results
 - **Parallel Execution**: Configurable with thread pool
@@ -66,13 +72,20 @@ export default defineConfig({
 
 ```
 tests/
-├── unit/                        # Unit tests with mocks (933 tests, 30 files)
+├── unit/                        # Unit tests with mocks (2,766 tests, 106 files)
 │   ├── __mocks__/              # Mock implementations
 │   │   └── n8n-nodes-base.test.ts
 │   ├── database/               # Database layer tests
 │   │   ├── database-adapter-unit.test.ts
 │   │   ├── node-repository-core.test.ts
 │   │   └── template-repository-core.test.ts
+│   ├── docker/                 # Docker configuration tests
+│   │   ├── config-security.test.ts
+│   │   ├── edge-cases.test.ts
+│   │   ├── parse-config.test.ts
+│   │   └── serve-command.test.ts
+│   ├── http-server/            # HTTP server tests
+│   │   └── multi-tenant-support.test.ts
 │   ├── loaders/                # Node loader tests
 │   │   └── node-loader.test.ts
 │   ├── mappers/                # Data mapper tests
@@ -86,6 +99,8 @@ tests/
 │   │   ├── node-parser.test.ts
 │   │   ├── property-extractor.test.ts
 │   │   └── simple-parser.test.ts
+│   ├── scripts/                # Script tests
+│   │   └── fetch-templates-extraction.test.ts
 │   ├── services/               # Service layer tests (largest test suite)
 │   │   ├── config-validator.test.ts
 │   │   ├── enhanced-config-validator.test.ts
@@ -100,22 +115,56 @@ tests/
 │   │   ├── workflow-diff-engine.test.ts
 │   │   ├── workflow-validator-comprehensive.test.ts
 │   │   └── workflow-validator.test.ts
+│   ├── telemetry/              # Telemetry tests
+│   │   └── telemetry-manager.test.ts
 │   └── utils/                  # Utility function tests
+│       ├── cache-utils.test.ts
 │       └── database-utils.test.ts
-├── integration/                 # Integration tests (249 tests, 14 files)
-│   ├── database/               # Database integration tests
+├── integration/                 # Integration tests (570 tests, 41 files)
+│   ├── n8n-api/                # n8n API integration tests (172 tests, 18 files)
+│   │   ├── executions/         # Execution management tests
+│   │   │   ├── get-execution.test.ts
+│   │   │   └── list-executions.test.ts
+│   │   ├── system/             # System tool tests
+│   │   │   ├── diagnostic.test.ts
+│   │   │   ├── health-check.test.ts
+│   │   │   └── list-tools.test.ts
+│   │   ├── utils/              # Test utilities
+│   │   │   ├── mcp-context.ts
+│   │   │   └── response-types.ts
+│   │   └── workflows/          # Workflow management tests
+│   │       ├── autofix-workflow.test.ts
+│   │       ├── create-workflow.test.ts
+│   │       ├── delete-workflow.test.ts
+│   │       ├── get-workflow-details.test.ts
+│   │       ├── get-workflow-minimal.test.ts
+│   │       ├── get-workflow-structure.test.ts
+│   │       ├── get-workflow.test.ts
+│   │       ├── list-workflows.test.ts
+│   │       ├── update-full-workflow.test.ts
+│   │       ├── update-partial-workflow.test.ts
+│   │       └── validate-workflow.test.ts
+│   ├── database/               # Database integration tests (226 tests)
 │   │   ├── connection-management.test.ts
 │   │   ├── fts5-search.test.ts
 │   │   ├── node-repository.test.ts
 │   │   ├── performance.test.ts
+│   │   ├── template-node-configs.test.ts
+│   │   ├── template-repository.test.ts
 │   │   └── transactions.test.ts
-│   ├── mcp-protocol/           # MCP protocol tests
+│   ├── docker/                 # Docker integration tests (18 tests)
+│   │   ├── docker-config.test.ts
+│   │   └── docker-entrypoint.test.ts
+│   ├── mcp-protocol/           # MCP protocol tests (119 tests)
 │   │   ├── basic-connection.test.ts
 │   │   ├── error-handling.test.ts
 │   │   ├── performance.test.ts
 │   │   ├── protocol-compliance.test.ts
 │   │   ├── session-management.test.ts
-│   │   └── tool-invocation.test.ts
+│   │   ├── tool-invocation.test.ts
+│   │   └── workflow-error-validation.test.ts
+│   ├── templates/              # Template tests (35 tests)
+│   │   └── metadata-operations.test.ts
 │   └── setup/                  # Integration test setup
 │       ├── integration-setup.ts
 │       └── msw-test-server.ts
@@ -368,9 +417,54 @@ describe('n8n-nodes-base mock', () => {
 
 ## Integration Testing
 
-Our integration tests verify the complete system behavior:
+Our integration tests verify the complete system behavior across 570 tests in four major categories:
 
-### MCP Protocol Testing
+### n8n API Integration Testing (172 tests)
+
+The n8n API integration tests verify all 18 MCP handler tools against a real n8n instance. These tests ensure our product layer (MCP handlers) work correctly end-to-end, not just the raw API client.
+
+**Test Organization:**
+- **Workflows** (11 handlers): Create, read, update (full/partial), delete, list, validate, autofix
+- **Executions** (2 handlers): Get execution details, list executions
+- **System** (3 handlers): Health check, list available tools, diagnostics
+
+**Example:**
+```typescript
+// tests/integration/n8n-api/workflows/create-workflow.test.ts
+describe('Integration: handleCreateWorkflow', () => {
+  it('should create a simple two-node workflow', async () => {
+    const response = await handleCreateWorkflow(
+      {
+        params: {
+          arguments: {
+            name: 'Test Workflow',
+            nodes: [webhook, setNode],
+            connections: { Webhook: { main: [[{ node: 'Set', type: 'main', index: 0 }]] } }
+          }
+        }
+      },
+      mcpContext
+    );
+
+    expect(response.success).toBe(true);
+    const workflow = response.data as WorkflowData;
+    expect(workflow.id).toBeDefined();
+    expect(workflow.nodes).toHaveLength(2);
+
+    // Cleanup
+    await handleDeleteWorkflow({ params: { arguments: { id: workflow.id } } }, mcpContext);
+  });
+});
+```
+
+**Key Features Tested:**
+- Real workflow creation, modification, deletion with cleanup
+- TypeScript type safety with response interfaces
+- Complete coverage of all 18 n8n API tools
+- Proper error handling and edge cases
+- Response format validation
+
+### MCP Protocol Testing (119 tests)
 
 ```typescript
 // tests/integration/mcp-protocol/tool-invocation.test.ts
@@ -381,20 +475,20 @@ describe('MCP Tool Invocation', () => {
   beforeEach(async () => {
     mcpServer = new TestableN8NMCPServer();
     await mcpServer.initialize();
-    
+
     const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();
     await mcpServer.connectToTransport(serverTransport);
-    
+
     client = new Client({ name: 'test-client', version: '1.0.0' }, {});
     await client.connect(clientTransport);
   });
 
   it('should list nodes with filtering', async () => {
-    const response = await client.callTool({ 
-      name: 'list_nodes', 
-      arguments: { category: 'trigger', limit: 10 } 
+    const response = await client.callTool({
+      name: 'list_nodes',
+      arguments: { category: 'trigger', limit: 10 }
     });
-    
+
     expectValidMCPResponse(response);
     const result = JSON.parse(response.content[0].text);
     expect(result.nodes).toHaveLength(10);
@@ -403,65 +497,104 @@ describe('MCP Tool Invocation', () => {
 });
 ```
 
-### Database Integration Testing
+### Database Integration Testing (226 tests)
 
 ```typescript
 // tests/integration/database/fts5-search.test.ts
 describe('FTS5 Search Integration', () => {
   it('should perform fuzzy search', async () => {
     const results = await nodeRepo.searchNodes('HTT', 'FUZZY');
-    
+
     expect(results.some(n => n.nodeType.includes('httpRequest'))).toBe(true);
     expect(results.some(n => n.displayName.includes('HTTP'))).toBe(true);
   });
 
   it('should handle complex boolean queries', async () => {
     const results = await nodeRepo.searchNodes('webhook OR http', 'OR');
-    
+
     expect(results.length).toBeGreaterThan(0);
-    expect(results.some(n => 
-      n.description?.includes('webhook') || 
+    expect(results.some(n =>
+      n.description?.includes('webhook') ||
       n.description?.includes('http')
     )).toBe(true);
   });
 });
 ```
 
+### Template Integration Testing (35 tests)
+
+Tests template fetching, storage, and metadata operations against the n8n.io API and local database.
+
+### Docker Integration Testing (18 tests)
+
+Tests Docker configuration parsing, entrypoint script, and security validation.
+
 ## Test Distribution and Coverage
 
 ### Test Distribution by Component
 
-Based on our 1,182 tests:
+Based on our 3,336 tests:
 
-1. **Services Layer** (~450 tests)
+**Integration Tests (570 tests):**
+1. **n8n API Integration** (172 tests)
+   - Workflow management handlers: 11 tools with comprehensive scenarios
+   - Execution management handlers: 2 tools
+   - System tool handlers: 3 tools
+   - TypeScript type safety with response interfaces
+
+2. **Database Integration** (226 tests)
+   - Repository operations and transactions
+   - FTS5 full-text search with fuzzy matching
+   - Performance and concurrent access tests
+   - Template node configurations
+
+3. **MCP Protocol** (119 tests)
+   - Protocol compliance and session management
+   - Tool invocation and error handling
+   - Performance and stress testing
+   - Workflow error validation
+
+4. **Templates & Docker** (53 tests)
+   - Template fetching and metadata operations
+   - Docker configuration and security validation
+
+**Unit Tests (2,766 tests):**
+1. **Services Layer** (largest suite)
    - `workflow-validator-comprehensive.test.ts`: 150+ tests
-   - `node-specific-validators.test.ts`: 120+ tests
-   - `n8n-validation.test.ts`: 80+ tests
-   - `n8n-api-client.test.ts`: 60+ tests
+   - `enhanced-config-validator.test.ts`: 120+ tests
+   - `node-specific-validators.test.ts`: 100+ tests
+   - `n8n-api-client.test.ts`: 80+ tests
+   - Config validation, property filtering, workflow diff engine
 
 2. **Parsers** (~200 tests)
-   - `simple-parser.test.ts`: 80+ tests
-   - `property-extractor.test.ts`: 70+ tests
-   - `node-parser.test.ts`: 50+ tests
+   - Node parsing with version support
+   - Property extraction and documentation mapping
+   - Simple parser for basic node information
 
-3. **MCP Integration** (~150 tests)
-   - `tool-invocation.test.ts`: 50+ tests
-   - `error-handling.test.ts`: 40+ tests
-   - `session-management.test.ts`: 30+ tests
+3. **Database Layer** (~150 tests)
+   - Repository core functionality with mocks
+   - Database adapter unit tests
+   - Template repository operations
 
-4. **Database** (~300 tests)
-   - Unit tests for repositories: 100+ tests
-   - Integration tests for FTS5 search: 80+ tests
-   - Transaction tests: 60+ tests
-   - Performance tests: 60+ tests
+4. **MCP Tools & HTTP Server** (~300 tests)
+   - Tool definitions and documentation system
+   - Multi-tenant support and security
+   - Configuration validation
+
+5. **Utils, Docker, Scripts, Telemetry** (remaining tests)
+   - Cache utilities, database helpers
+   - Docker config security and parsing
+   - Template extraction scripts
+   - Telemetry tracking
 
 ### Test Execution Performance
 
 From our CI runs:
 - **Fastest tests**: Unit tests with mocks (<1ms each)
-- **Slowest tests**: Integration tests with real database (100-5000ms)
+- **Slowest tests**: Integration tests with real database and n8n API (100-5000ms)
 - **Average test time**: ~20ms per test
-- **Total suite execution**: Under 3 minutes in CI
+- **Total suite execution**: ~3 minutes in CI (with coverage)
+- **Parallel execution**: Configurable thread pool for optimal performance
 
 ## CI/CD Pipeline
 

docs/workflow-diff-examples.md

@@ -296,6 +296,193 @@ The `n8n_update_partial_workflow` tool allows you to make targeted changes to wo
 }
 ```
 
+### Example 5: Large Batch Workflow Refactoring
+Demonstrates handling many operations in a single request - no longer limited to 5 operations!
+
+```json
+{
+  "id": "workflow-batch",
+  "operations": [
+    // Add 10 processing nodes
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Filter Active Users",
+        "type": "n8n-nodes-base.filter",
+        "position": [400, 200],
+        "parameters": { "conditions": { "boolean": [{ "value1": "={{$json.active}}", "value2": true }] } }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Transform User Data",
+        "type": "n8n-nodes-base.set",
+        "position": [600, 200],
+        "parameters": { "values": { "string": [{ "name": "formatted_name", "value": "={{$json.firstName}} {{$json.lastName}}" }] } }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Validate Email",
+        "type": "n8n-nodes-base.if",
+        "position": [800, 200],
+        "parameters": { "conditions": { "string": [{ "value1": "={{$json.email}}", "operation": "contains", "value2": "@" }] } }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Enrich with API",
+        "type": "n8n-nodes-base.httpRequest",
+        "position": [1000, 150],
+        "parameters": { "url": "https://api.example.com/enrich", "method": "POST" }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Log Invalid Emails",
+        "type": "n8n-nodes-base.code",
+        "position": [1000, 350],
+        "parameters": { "jsCode": "console.log('Invalid email:', $json.email);\nreturn $json;" }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Merge Results",
+        "type": "n8n-nodes-base.merge",
+        "position": [1200, 250]
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Deduplicate",
+        "type": "n8n-nodes-base.removeDuplicates",
+        "position": [1400, 250],
+        "parameters": { "propertyName": "id" }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Sort by Date",
+        "type": "n8n-nodes-base.sort",
+        "position": [1600, 250],
+        "parameters": { "sortFieldsUi": { "sortField": [{ "fieldName": "created_at", "order": "descending" }] } }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Batch for DB",
+        "type": "n8n-nodes-base.splitInBatches",
+        "position": [1800, 250],
+        "parameters": { "batchSize": 100 }
+      }
+    },
+    {
+      "type": "addNode",
+      "node": {
+        "name": "Save to Database",
+        "type": "n8n-nodes-base.postgres",
+        "position": [2000, 250],
+        "parameters": { "operation": "insert", "table": "processed_users" }
+      }
+    },
+    // Connect all the nodes
+    {
+      "type": "addConnection",
+      "source": "Get Users",
+      "target": "Filter Active Users"
+    },
+    {
+      "type": "addConnection",
+      "source": "Filter Active Users",
+      "target": "Transform User Data"
+    },
+    {
+      "type": "addConnection",
+      "source": "Transform User Data",
+      "target": "Validate Email"
+    },
+    {
+      "type": "addConnection",
+      "source": "Validate Email",
+      "sourceOutput": "true",
+      "target": "Enrich with API"
+    },
+    {
+      "type": "addConnection",
+      "source": "Validate Email",
+      "sourceOutput": "false",
+      "target": "Log Invalid Emails"
+    },
+    {
+      "type": "addConnection",
+      "source": "Enrich with API",
+      "target": "Merge Results"
+    },
+    {
+      "type": "addConnection",
+      "source": "Log Invalid Emails",
+      "target": "Merge Results",
+      "targetInput": "input2"
+    },
+    {
+      "type": "addConnection",
+      "source": "Merge Results",
+      "target": "Deduplicate"
+    },
+    {
+      "type": "addConnection",
+      "source": "Deduplicate",
+      "target": "Sort by Date"
+    },
+    {
+      "type": "addConnection",
+      "source": "Sort by Date",
+      "target": "Batch for DB"
+    },
+    {
+      "type": "addConnection",
+      "source": "Batch for DB",
+      "target": "Save to Database"
+    },
+    // Update workflow metadata
+    {
+      "type": "updateName",
+      "name": "User Processing Pipeline v2"
+    },
+    {
+      "type": "updateSettings",
+      "settings": {
+        "executionOrder": "v1",
+        "timezone": "UTC",
+        "saveDataSuccessExecution": "all"
+      }
+    },
+    {
+      "type": "addTag",
+      "tag": "production"
+    },
+    {
+      "type": "addTag",
+      "tag": "user-processing"
+    },
+    {
+      "type": "addTag",
+      "tag": "v2"
+    }
+  ]
+}
+```
+
+This example shows 26 operations in a single request, creating a complete data processing pipeline with proper error handling, validation, and batch processing.
+
 ## Best Practices
 
 1. **Use Descriptive Names**: Always provide clear node names and descriptions for operations

package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.12.1",
+  "version": "2.15.5",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "bin": {
@@ -31,12 +31,16 @@
     "test:watch": "vitest watch",
     "test:unit": "vitest run tests/unit",
     "test:integration": "vitest run --config vitest.config.integration.ts",
+    "test:integration:n8n": "vitest run tests/integration/n8n-api",
+    "test:cleanup:orphans": "tsx tests/integration/n8n-api/scripts/cleanup-orphans.ts",
     "test:e2e": "vitest run tests/e2e",
     "lint": "tsc --noEmit",
     "typecheck": "tsc --noEmit",
     "update:n8n": "node scripts/update-n8n-deps.js",
     "update:n8n:check": "node scripts/update-n8n-deps.js --dry-run",
     "fetch:templates": "node dist/scripts/fetch-templates.js",
+    "fetch:templates:update": "node dist/scripts/fetch-templates.js --update",
+    "fetch:templates:extract": "node dist/scripts/fetch-templates.js --extract-only",
     "fetch:templates:robust": "node dist/scripts/fetch-templates-robust.js",
     "prebuild:fts5": "npx tsx scripts/prebuild-fts5.ts",
     "test:templates": "node dist/scripts/test-templates.js",
@@ -128,13 +132,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.2",
-    "@n8n/n8n-nodes-langchain": "^1.110.0",
+    "@n8n/n8n-nodes-langchain": "^1.112.2",
+    "@supabase/supabase-js": "^2.57.4",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "lru-cache": "^11.2.1",
-    "n8n": "^1.111.0",
-    "n8n-core": "^1.110.0",
-    "n8n-workflow": "^1.108.0",
+    "n8n": "^1.113.3",
+    "n8n-core": "^1.112.1",
+    "n8n-workflow": "^1.110.0",
     "openai": "^4.77.0",
     "sql.js": "^1.13.0",
     "uuid": "^10.0.0",

package.runtime.json

@@ -1,10 +1,11 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.12.0",
+  "version": "2.15.1",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.2",
+    "@supabase/supabase-js": "^2.57.4",
     "express": "^5.1.0",
     "dotenv": "^16.5.0",
     "lru-cache": "^11.2.1",

scripts/export-webhook-workflows.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env tsx
+
+/**
+ * Export Webhook Workflow JSONs
+ *
+ * Generates the 4 webhook workflow JSON files needed for integration testing.
+ * These workflows must be imported into n8n and activated manually.
+ */
+
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { exportAllWebhookWorkflows } from '../tests/integration/n8n-api/utils/webhook-workflows';
+
+const OUTPUT_DIR = join(process.cwd(), 'workflows-for-import');
+
+// Create output directory
+mkdirSync(OUTPUT_DIR, { recursive: true });
+
+// Generate all workflow JSONs
+const workflows = exportAllWebhookWorkflows();
+
+// Write each workflow to a separate file
+Object.entries(workflows).forEach(([method, workflow]) => {
+  const filename = `webhook-${method.toLowerCase()}.json`;
+  const filepath = join(OUTPUT_DIR, filename);
+
+  writeFileSync(filepath, JSON.stringify(workflow, null, 2), 'utf-8');
+
+  console.log(`✓ Generated: ${filename}`);
+});
+
+console.log(`\n✓ All workflow JSONs written to: ${OUTPUT_DIR}`);
+console.log('\nNext steps:');
+console.log('1. Import each JSON file into your n8n instance');
+console.log('2. Activate each workflow in the n8n UI');
+console.log('3. Copy the webhook URLs from each workflow (open workflow → Webhook node → copy URL)');
+console.log('4. Add them to your .env file:');
+console.log('   N8N_TEST_WEBHOOK_GET_URL=https://your-n8n.com/webhook/mcp-test-get');
+console.log('   N8N_TEST_WEBHOOK_POST_URL=https://your-n8n.com/webhook/mcp-test-post');
+console.log('   N8N_TEST_WEBHOOK_PUT_URL=https://your-n8n.com/webhook/mcp-test-put');
+console.log('   N8N_TEST_WEBHOOK_DELETE_URL=https://your-n8n.com/webhook/mcp-test-delete');

scripts/test-error-message-tracking.ts

@@ -0,0 +1,58 @@
+/**
+ * Test script to verify error message tracking is working
+ */
+
+import { telemetry } from '../src/telemetry';
+
+async function testErrorTracking() {
+  console.log('=== Testing Error Message Tracking ===\n');
+
+  // Track session first
+  console.log('1. Starting session...');
+  telemetry.trackSessionStart();
+
+  // Track an error WITH a message
+  console.log('\n2. Tracking error WITH message:');
+  const testErrorMessage = 'This is a test error message with sensitive data: password=secret123 and test@example.com';
+  telemetry.trackError(
+    'TypeError',
+    'tool_execution',
+    'test_tool',
+    testErrorMessage
+  );
+  console.log(`   Original message: "${testErrorMessage}"`);
+
+  // Track an error WITHOUT a message
+  console.log('\n3. Tracking error WITHOUT message:');
+  telemetry.trackError(
+    'Error',
+    'tool_execution',
+    'test_tool2'
+  );
+
+  // Check the event queue
+  const metrics = telemetry.getMetrics();
+  console.log('\n4. Telemetry metrics:');
+  console.log('   Status:', metrics.status);
+  console.log('   Events queued:', metrics.tracking.eventsQueued);
+
+  // Get raw event queue to inspect
+  const eventTracker = (telemetry as any).eventTracker;
+  const queue = eventTracker.getEventQueue();
+
+  console.log('\n5. Event queue contents:');
+  queue.forEach((event, i) => {
+    console.log(`\n   Event ${i + 1}:`);
+    console.log(`   - Type: ${event.event}`);
+    console.log(`   - Properties:`, JSON.stringify(event.properties, null, 6));
+  });
+
+  // Flush to database
+  console.log('\n6. Flushing to database...');
+  await telemetry.flush();
+
+  console.log('\n7. Done! Check Supabase for error events with "error" field.');
+  console.log('   Query: SELECT * FROM telemetry_events WHERE event = \'error_occurred\' ORDER BY created_at DESC LIMIT 5;');
+}
+
+testErrorTracking().catch(console.error);

scripts/test-operation-validation.ts

@@ -0,0 +1,178 @@
+/**
+ * Test script for operation and resource validation with Google Drive example
+ */
+
+import { DatabaseAdapter } from '../src/database/database-adapter';
+import { NodeRepository } from '../src/database/node-repository';
+import { EnhancedConfigValidator } from '../src/services/enhanced-config-validator';
+import { WorkflowValidator } from '../src/services/workflow-validator';
+import { createDatabaseAdapter } from '../src/database/database-adapter';
+import { logger } from '../src/utils/logger';
+import chalk from 'chalk';
+
+async function testOperationValidation() {
+  console.log(chalk.blue('Testing Operation and Resource Validation'));
+  console.log('='.repeat(60));
+
+  // Initialize database
+  const dbPath = process.env.NODE_DB_PATH || 'data/nodes.db';
+  const db = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(db);
+
+  // Initialize similarity services
+  EnhancedConfigValidator.initializeSimilarityServices(repository);
+
+  // Test 1: Invalid operation "listFiles"
+  console.log(chalk.yellow('\n📝 Test 1: Google Drive with invalid operation "listFiles"'));
+  const invalidConfig = {
+    resource: 'fileFolder',
+    operation: 'listFiles'
+  };
+
+  const node = repository.getNode('nodes-base.googleDrive');
+  if (!node) {
+    console.error(chalk.red('Google Drive node not found in database'));
+    process.exit(1);
+  }
+
+  const result1 = EnhancedConfigValidator.validateWithMode(
+    'nodes-base.googleDrive',
+    invalidConfig,
+    node.properties,
+    'operation',
+    'ai-friendly'
+  );
+
+  console.log(`Valid: ${result1.valid ? chalk.green('✓') : chalk.red('✗')}`);
+  if (result1.errors.length > 0) {
+    console.log(chalk.red('Errors:'));
+    result1.errors.forEach(error => {
+      console.log(`  - ${error.property}: ${error.message}`);
+      if (error.fix) {
+        console.log(chalk.cyan(`    Fix: ${error.fix}`));
+      }
+    });
+  }
+
+  // Test 2: Invalid resource "files" (should be singular)
+  console.log(chalk.yellow('\n📝 Test 2: Google Drive with invalid resource "files"'));
+  const pluralResourceConfig = {
+    resource: 'files',
+    operation: 'download'
+  };
+
+  const result2 = EnhancedConfigValidator.validateWithMode(
+    'nodes-base.googleDrive',
+    pluralResourceConfig,
+    node.properties,
+    'operation',
+    'ai-friendly'
+  );
+
+  console.log(`Valid: ${result2.valid ? chalk.green('✓') : chalk.red('✗')}`);
+  if (result2.errors.length > 0) {
+    console.log(chalk.red('Errors:'));
+    result2.errors.forEach(error => {
+      console.log(`  - ${error.property}: ${error.message}`);
+      if (error.fix) {
+        console.log(chalk.cyan(`    Fix: ${error.fix}`));
+      }
+    });
+  }
+
+  // Test 3: Valid configuration
+  console.log(chalk.yellow('\n📝 Test 3: Google Drive with valid configuration'));
+  const validConfig = {
+    resource: 'file',
+    operation: 'download'
+  };
+
+  const result3 = EnhancedConfigValidator.validateWithMode(
+    'nodes-base.googleDrive',
+    validConfig,
+    node.properties,
+    'operation',
+    'ai-friendly'
+  );
+
+  console.log(`Valid: ${result3.valid ? chalk.green('✓') : chalk.red('✗')}`);
+  if (result3.errors.length > 0) {
+    console.log(chalk.red('Errors:'));
+    result3.errors.forEach(error => {
+      console.log(`  - ${error.property}: ${error.message}`);
+    });
+  } else {
+    console.log(chalk.green('No errors - configuration is valid!'));
+  }
+
+  // Test 4: Test in workflow context
+  console.log(chalk.yellow('\n📝 Test 4: Full workflow with invalid Google Drive node'));
+  const workflow = {
+    name: 'Test Workflow',
+    nodes: [
+      {
+        id: '1',
+        name: 'Google Drive',
+        type: 'n8n-nodes-base.googleDrive',
+        position: [100, 100] as [number, number],
+        parameters: {
+          resource: 'fileFolder',
+          operation: 'listFiles' // Invalid operation
+        }
+      }
+    ],
+    connections: {}
+  };
+
+  const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+  const workflowResult = await validator.validateWorkflow(workflow, {
+    validateNodes: true,
+    profile: 'ai-friendly'
+  });
+
+  console.log(`Workflow Valid: ${workflowResult.valid ? chalk.green('✓') : chalk.red('✗')}`);
+  if (workflowResult.errors.length > 0) {
+    console.log(chalk.red('Errors:'));
+    workflowResult.errors.forEach(error => {
+      console.log(`  - ${error.nodeName || 'Workflow'}: ${error.message}`);
+      if (error.details?.fix) {
+        console.log(chalk.cyan(`    Fix: ${error.details.fix}`));
+      }
+    });
+  }
+
+  // Test 5: Typo in operation
+  console.log(chalk.yellow('\n📝 Test 5: Typo in operation "downlod"'));
+  const typoConfig = {
+    resource: 'file',
+    operation: 'downlod' // Typo
+  };
+
+  const result5 = EnhancedConfigValidator.validateWithMode(
+    'nodes-base.googleDrive',
+    typoConfig,
+    node.properties,
+    'operation',
+    'ai-friendly'
+  );
+
+  console.log(`Valid: ${result5.valid ? chalk.green('✓') : chalk.red('✗')}`);
+  if (result5.errors.length > 0) {
+    console.log(chalk.red('Errors:'));
+    result5.errors.forEach(error => {
+      console.log(`  - ${error.property}: ${error.message}`);
+      if (error.fix) {
+        console.log(chalk.cyan(`    Fix: ${error.fix}`));
+      }
+    });
+  }
+
+  console.log(chalk.green('\n✅ All tests completed!'));
+  db.close();
+}
+
+// Run tests
+testOperationValidation().catch(error => {
+  console.error(chalk.red('Error running tests:'), error);
+  process.exit(1);
+});

scripts/test-telemetry-debug.ts

@@ -0,0 +1,118 @@
+#!/usr/bin/env npx tsx
+/**
+ * Debug script for telemetry integration
+ * Tests direct Supabase connection
+ */
+
+import { createClient } from '@supabase/supabase-js';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+async function debugTelemetry() {
+  console.log('🔍 Debugging Telemetry Integration\n');
+
+  const supabaseUrl = process.env.SUPABASE_URL;
+  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY;
+
+  if (!supabaseUrl || !supabaseAnonKey) {
+    console.error('❌ Missing SUPABASE_URL or SUPABASE_ANON_KEY');
+    process.exit(1);
+  }
+
+  console.log('Environment:');
+  console.log('  URL:', supabaseUrl);
+  console.log('  Key:', supabaseAnonKey.substring(0, 30) + '...');
+
+  // Create Supabase client
+  const supabase = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  // Test 1: Direct insert to telemetry_events
+  console.log('\n📝 Test 1: Direct insert to telemetry_events...');
+  const testEvent = {
+    user_id: 'test-user-123',
+    event: 'test_event',
+    properties: {
+      test: true,
+      timestamp: new Date().toISOString()
+    }
+  };
+
+  const { data: eventData, error: eventError } = await supabase
+    .from('telemetry_events')
+    .insert([testEvent])
+    .select();
+
+  if (eventError) {
+    console.error('❌ Event insert failed:', eventError);
+  } else {
+    console.log('✅ Event inserted successfully:', eventData);
+  }
+
+  // Test 2: Direct insert to telemetry_workflows
+  console.log('\n📝 Test 2: Direct insert to telemetry_workflows...');
+  const testWorkflow = {
+    user_id: 'test-user-123',
+    workflow_hash: 'test-hash-' + Date.now(),
+    node_count: 3,
+    node_types: ['webhook', 'http', 'slack'],
+    has_trigger: true,
+    has_webhook: true,
+    complexity: 'simple',
+    sanitized_workflow: {
+      nodes: [],
+      connections: {}
+    }
+  };
+
+  const { data: workflowData, error: workflowError } = await supabase
+    .from('telemetry_workflows')
+    .insert([testWorkflow])
+    .select();
+
+  if (workflowError) {
+    console.error('❌ Workflow insert failed:', workflowError);
+  } else {
+    console.log('✅ Workflow inserted successfully:', workflowData);
+  }
+
+  // Test 3: Try to read data (should fail with anon key due to RLS)
+  console.log('\n📖 Test 3: Attempting to read data (should fail due to RLS)...');
+  const { data: readData, error: readError } = await supabase
+    .from('telemetry_events')
+    .select('*')
+    .limit(1);
+
+  if (readError) {
+    console.log('✅ Read correctly blocked by RLS:', readError.message);
+  } else {
+    console.log('⚠️  Unexpected: Read succeeded (RLS may not be working):', readData);
+  }
+
+  // Test 4: Check table existence
+  console.log('\n🔍 Test 4: Verifying tables exist...');
+  const { data: tables, error: tablesError } = await supabase
+    .rpc('get_tables', { schema_name: 'public' })
+    .select('*');
+
+  if (tablesError) {
+    // This is expected - the RPC function might not exist
+    console.log('ℹ️  Cannot list tables (RPC function not available)');
+  } else {
+    console.log('Tables found:', tables);
+  }
+
+  console.log('\n✨ Debug completed! Check your Supabase dashboard for the test data.');
+  console.log('Dashboard: https://supabase.com/dashboard/project/ydyufsohxdfpopqbubwk/editor');
+}
+
+debugTelemetry().catch(error => {
+  console.error('❌ Debug failed:', error);
+  process.exit(1);
+});

scripts/test-telemetry-direct.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env npx tsx
+/**
+ * Direct telemetry test with hardcoded credentials
+ */
+
+import { createClient } from '@supabase/supabase-js';
+
+const TELEMETRY_BACKEND = {
+  URL: 'https://ydyufsohxdfpopqbubwk.supabase.co',
+  ANON_KEY: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InlkeXVmc29oeGRmcG9wcWJ1YndrIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Mzc2MzAxMDgsImV4cCI6MjA1MzIwNjEwOH0.LsUTx9OsNtnqg-jxXaJPc84aBHVDehHiMaFoF2Ir8s0'
+};
+
+async function testDirect() {
+  console.log('🧪 Direct Telemetry Test\n');
+
+  const supabase = createClient(TELEMETRY_BACKEND.URL, TELEMETRY_BACKEND.ANON_KEY, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  const testEvent = {
+    user_id: 'direct-test-' + Date.now(),
+    event: 'direct_test',
+    properties: {
+      source: 'test-telemetry-direct.ts',
+      timestamp: new Date().toISOString()
+    }
+  };
+
+  console.log('Sending event:', testEvent);
+
+  const { data, error } = await supabase
+    .from('telemetry_events')
+    .insert([testEvent]);
+
+  if (error) {
+    console.error('❌ Failed:', error);
+  } else {
+    console.log('✅ Success! Event sent directly to Supabase');
+    console.log('Response:', data);
+  }
+}
+
+testDirect().catch(console.error);

scripts/test-telemetry-env.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test telemetry environment variable override
+ */
+
+import { TelemetryConfigManager } from '../src/telemetry/config-manager';
+import { telemetry } from '../src/telemetry/telemetry-manager';
+
+async function testEnvOverride() {
+  console.log('🧪 Testing Telemetry Environment Variable Override\n');
+
+  const configManager = TelemetryConfigManager.getInstance();
+
+  // Test 1: Check current status without env var
+  console.log('Test 1: Without environment variable');
+  console.log('Is Enabled:', configManager.isEnabled());
+  console.log('Status:', configManager.getStatus());
+
+  // Test 2: Set environment variable and check again
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Test 2: With N8N_MCP_TELEMETRY_DISABLED=true');
+  process.env.N8N_MCP_TELEMETRY_DISABLED = 'true';
+
+  // Force reload by creating new instance (for testing)
+  const newConfigManager = TelemetryConfigManager.getInstance();
+  console.log('Is Enabled:', newConfigManager.isEnabled());
+  console.log('Status:', newConfigManager.getStatus());
+
+  // Test 3: Try tracking with env disabled
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Test 3: Attempting to track with telemetry disabled');
+  telemetry.trackToolUsage('test_tool', true, 100);
+  console.log('Tool usage tracking attempted (should be ignored)');
+
+  // Test 4: Alternative env vars
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Test 4: Alternative environment variables');
+
+  delete process.env.N8N_MCP_TELEMETRY_DISABLED;
+  process.env.TELEMETRY_DISABLED = 'true';
+  console.log('With TELEMETRY_DISABLED=true:', newConfigManager.isEnabled());
+
+  delete process.env.TELEMETRY_DISABLED;
+  process.env.DISABLE_TELEMETRY = 'true';
+  console.log('With DISABLE_TELEMETRY=true:', newConfigManager.isEnabled());
+
+  // Test 5: Env var takes precedence over config
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Test 5: Environment variable precedence');
+
+  // Enable via config
+  newConfigManager.enable();
+  console.log('After enabling via config:', newConfigManager.isEnabled());
+
+  // But env var should still override
+  process.env.N8N_MCP_TELEMETRY_DISABLED = 'true';
+  console.log('With env var set (should override config):', newConfigManager.isEnabled());
+
+  console.log('\n✅ All tests completed!');
+}
+
+testEnvOverride().catch(console.error);

scripts/test-telemetry-integration.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env npx tsx
+/**
+ * Integration test for the telemetry manager
+ */
+
+import { telemetry } from '../src/telemetry/telemetry-manager';
+
+async function testIntegration() {
+  console.log('🧪 Testing Telemetry Manager Integration\n');
+
+  // Check status
+  console.log('Status:', telemetry.getStatus());
+
+  // Track session start
+  console.log('\nTracking session start...');
+  telemetry.trackSessionStart();
+
+  // Track tool usage
+  console.log('Tracking tool usage...');
+  telemetry.trackToolUsage('search_nodes', true, 150);
+  telemetry.trackToolUsage('get_node_info', true, 75);
+  telemetry.trackToolUsage('validate_workflow', false, 200);
+
+  // Track errors
+  console.log('Tracking errors...');
+  telemetry.trackError('ValidationError', 'workflow_validation', 'validate_workflow', 'Required field missing: nodes array is empty');
+
+  // Track a test workflow
+  console.log('Tracking workflow creation...');
+  const testWorkflow = {
+    nodes: [
+      {
+        id: '1',
+        type: 'n8n-nodes-base.webhook',
+        name: 'Webhook',
+        position: [0, 0],
+        parameters: {
+          path: '/test-webhook',
+          httpMethod: 'POST'
+        }
+      },
+      {
+        id: '2',
+        type: 'n8n-nodes-base.httpRequest',
+        name: 'HTTP Request',
+        position: [250, 0],
+        parameters: {
+          url: 'https://api.example.com/endpoint',
+          method: 'POST',
+          authentication: 'genericCredentialType',
+          genericAuthType: 'httpHeaderAuth',
+          sendHeaders: true,
+          headerParameters: {
+            parameters: [
+              {
+                name: 'Authorization',
+                value: 'Bearer sk-1234567890abcdef'
+              }
+            ]
+          }
+        }
+      },
+      {
+        id: '3',
+        type: 'n8n-nodes-base.slack',
+        name: 'Slack',
+        position: [500, 0],
+        parameters: {
+          channel: '#notifications',
+          text: 'Workflow completed!'
+        }
+      }
+    ],
+    connections: {
+      '1': {
+        main: [[{ node: '2', type: 'main', index: 0 }]]
+      },
+      '2': {
+        main: [[{ node: '3', type: 'main', index: 0 }]]
+      }
+    }
+  };
+
+  telemetry.trackWorkflowCreation(testWorkflow, true);
+
+  // Force flush
+  console.log('\nFlushing telemetry data...');
+  await telemetry.flush();
+
+  console.log('\n✅ Telemetry integration test completed!');
+  console.log('Check your Supabase dashboard for the telemetry data.');
+}
+
+testIntegration().catch(console.error);

scripts/test-telemetry-no-select.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test telemetry without requesting data back
+ */
+
+import { createClient } from '@supabase/supabase-js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function testNoSelect() {
+  const supabaseUrl = process.env.SUPABASE_URL!;
+  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY!;
+
+  console.log('🧪 Telemetry Test (No Select)\n');
+
+  const supabase = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  // Insert WITHOUT .select() - just fire and forget
+  const testData = {
+    user_id: 'test-' + Date.now(),
+    event: 'test_event',
+    properties: { test: true }
+  };
+
+  console.log('Inserting:', testData);
+
+  const { error } = await supabase
+    .from('telemetry_events')
+    .insert([testData]);  // No .select() here!
+
+  if (error) {
+    console.error('❌ Failed:', error);
+  } else {
+    console.log('✅ Success! Data inserted (no response data)');
+  }
+
+  // Test workflow insert too
+  const testWorkflow = {
+    user_id: 'test-' + Date.now(),
+    workflow_hash: 'hash-' + Date.now(),
+    node_count: 3,
+    node_types: ['webhook', 'http', 'slack'],
+    has_trigger: true,
+    has_webhook: true,
+    complexity: 'simple',
+    sanitized_workflow: { nodes: [], connections: {} }
+  };
+
+  console.log('\nInserting workflow:', testWorkflow);
+
+  const { error: workflowError } = await supabase
+    .from('telemetry_workflows')
+    .insert([testWorkflow]);  // No .select() here!
+
+  if (workflowError) {
+    console.error('❌ Workflow failed:', workflowError);
+  } else {
+    console.log('✅ Workflow inserted successfully!');
+  }
+}
+
+testNoSelect().catch(console.error);

scripts/test-telemetry-security.ts

@@ -0,0 +1,87 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test that RLS properly protects data
+ */
+
+import { createClient } from '@supabase/supabase-js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function testSecurity() {
+  const supabaseUrl = process.env.SUPABASE_URL!;
+  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY!;
+
+  console.log('🔒 Testing Telemetry Security (RLS)\n');
+
+  const supabase = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  // Test 1: Verify anon can INSERT
+  console.log('Test 1: Anonymous INSERT (should succeed)...');
+  const testData = {
+    user_id: 'security-test-' + Date.now(),
+    event: 'security_test',
+    properties: { test: true }
+  };
+
+  const { error: insertError } = await supabase
+    .from('telemetry_events')
+    .insert([testData]);
+
+  if (insertError) {
+    console.error('❌ Insert failed:', insertError.message);
+  } else {
+    console.log('✅ Insert succeeded (as expected)');
+  }
+
+  // Test 2: Verify anon CANNOT SELECT
+  console.log('\nTest 2: Anonymous SELECT (should fail)...');
+  const { data, error: selectError } = await supabase
+    .from('telemetry_events')
+    .select('*')
+    .limit(1);
+
+  if (selectError) {
+    console.log('✅ Select blocked by RLS (as expected):', selectError.message);
+  } else if (data && data.length > 0) {
+    console.error('❌ SECURITY ISSUE: Anon can read data!', data);
+  } else if (data && data.length === 0) {
+    console.log('⚠️  Select returned empty array (might be RLS working)');
+  }
+
+  // Test 3: Verify anon CANNOT UPDATE
+  console.log('\nTest 3: Anonymous UPDATE (should fail)...');
+  const { error: updateError } = await supabase
+    .from('telemetry_events')
+    .update({ event: 'hacked' })
+    .eq('user_id', 'test');
+
+  if (updateError) {
+    console.log('✅ Update blocked (as expected):', updateError.message);
+  } else {
+    console.error('❌ SECURITY ISSUE: Anon can update data!');
+  }
+
+  // Test 4: Verify anon CANNOT DELETE
+  console.log('\nTest 4: Anonymous DELETE (should fail)...');
+  const { error: deleteError } = await supabase
+    .from('telemetry_events')
+    .delete()
+    .eq('user_id', 'test');
+
+  if (deleteError) {
+    console.log('✅ Delete blocked (as expected):', deleteError.message);
+  } else {
+    console.error('❌ SECURITY ISSUE: Anon can delete data!');
+  }
+
+  console.log('\n✨ Security test completed!');
+  console.log('Summary: Anonymous users can INSERT (for telemetry) but cannot READ/UPDATE/DELETE');
+}
+
+testSecurity().catch(console.error);

scripts/test-telemetry-simple.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env npx tsx
+/**
+ * Simple test to verify telemetry works
+ */
+
+import { createClient } from '@supabase/supabase-js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function testSimple() {
+  const supabaseUrl = process.env.SUPABASE_URL!;
+  const supabaseAnonKey = process.env.SUPABASE_ANON_KEY!;
+
+  console.log('🧪 Simple Telemetry Test\n');
+
+  const supabase = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  // Simple insert
+  const testData = {
+    user_id: 'simple-test-' + Date.now(),
+    event: 'test_event',
+    properties: { test: true }
+  };
+
+  console.log('Inserting:', testData);
+
+  const { data, error } = await supabase
+    .from('telemetry_events')
+    .insert([testData])
+    .select();
+
+  if (error) {
+    console.error('❌ Failed:', error);
+  } else {
+    console.log('✅ Success! Inserted:', data);
+  }
+}
+
+testSimple().catch(console.error);

scripts/test-workflow-insert.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test direct workflow insert to Supabase
+ */
+
+import { createClient } from '@supabase/supabase-js';
+
+const TELEMETRY_BACKEND = {
+  URL: 'https://ydyufsohxdfpopqbubwk.supabase.co',
+  ANON_KEY: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InlkeXVmc29oeGRmcG9wcWJ1YndrIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTg3OTYyMDAsImV4cCI6MjA3NDM3MjIwMH0.xESphg6h5ozaDsm4Vla3QnDJGc6Nc_cpfoqTHRynkCk'
+};
+
+async function testWorkflowInsert() {
+  const supabase = createClient(TELEMETRY_BACKEND.URL, TELEMETRY_BACKEND.ANON_KEY, {
+    auth: {
+      persistSession: false,
+      autoRefreshToken: false,
+    }
+  });
+
+  const testWorkflow = {
+    user_id: 'direct-test-' + Date.now(),
+    workflow_hash: 'hash-direct-' + Date.now(),
+    node_count: 2,
+    node_types: ['webhook', 'http'],
+    has_trigger: true,
+    has_webhook: true,
+    complexity: 'simple' as const,
+    sanitized_workflow: {
+      nodes: [
+        { id: '1', type: 'webhook', parameters: {} },
+        { id: '2', type: 'http', parameters: {} }
+      ],
+      connections: {}
+    }
+  };
+
+  console.log('Attempting direct insert to telemetry_workflows...');
+  console.log('Data:', JSON.stringify(testWorkflow, null, 2));
+
+  const { data, error } = await supabase
+    .from('telemetry_workflows')
+    .insert([testWorkflow]);
+
+  if (error) {
+    console.error('\n❌ Error:', error);
+  } else {
+    console.log('\n✅ Success! Workflow inserted');
+    if (data) {
+      console.log('Response:', data);
+    }
+  }
+}
+
+testWorkflowInsert().catch(console.error);

scripts/test-workflow-sanitizer.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test workflow sanitizer
+ */
+
+import { WorkflowSanitizer } from '../src/telemetry/workflow-sanitizer';
+
+const testWorkflow = {
+  nodes: [
+    {
+      id: 'webhook1',
+      type: 'n8n-nodes-base.webhook',
+      name: 'Webhook',
+      position: [0, 0],
+      parameters: { 
+        path: '/test-webhook',
+        httpMethod: 'POST'
+      }
+    },
+    {
+      id: 'http1',
+      type: 'n8n-nodes-base.httpRequest',
+      name: 'HTTP Request',
+      position: [250, 0],
+      parameters: { 
+        url: 'https://api.example.com/endpoint',
+        method: 'GET',
+        authentication: 'genericCredentialType',
+        sendHeaders: true,
+        headerParameters: {
+          parameters: [
+            {
+              name: 'Authorization',
+              value: 'Bearer sk-1234567890abcdef'
+            }
+          ]
+        }
+      }
+    }
+  ],
+  connections: {
+    'webhook1': {
+      main: [[{ node: 'http1', type: 'main', index: 0 }]]
+    }
+  }
+};
+
+console.log('🧪 Testing Workflow Sanitizer\n');
+console.log('Original workflow has', testWorkflow.nodes.length, 'nodes');
+
+try {
+  const sanitized = WorkflowSanitizer.sanitizeWorkflow(testWorkflow);
+  
+  console.log('\n✅ Sanitization successful!');
+  console.log('\nSanitized output:');
+  console.log(JSON.stringify(sanitized, null, 2));
+  
+  console.log('\n📊 Metrics:');
+  console.log('- Workflow Hash:', sanitized.workflowHash);
+  console.log('- Node Count:', sanitized.nodeCount);
+  console.log('- Node Types:', sanitized.nodeTypes);
+  console.log('- Has Trigger:', sanitized.hasTrigger);
+  console.log('- Has Webhook:', sanitized.hasWebhook);
+  console.log('- Complexity:', sanitized.complexity);
+} catch (error) {
+  console.error('❌ Sanitization failed:', error);
+}

scripts/test-workflow-tracking-debug.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env npx tsx
+/**
+ * Debug workflow tracking in telemetry manager
+ */
+
+import { TelemetryManager } from '../src/telemetry/telemetry-manager';
+
+// Get the singleton instance
+const telemetry = TelemetryManager.getInstance();
+
+const testWorkflow = {
+  nodes: [
+    {
+      id: 'webhook1',
+      type: 'n8n-nodes-base.webhook',
+      name: 'Webhook',
+      position: [0, 0],
+      parameters: { 
+        path: '/test-' + Date.now(),
+        httpMethod: 'POST'
+      }
+    },
+    {
+      id: 'http1',
+      type: 'n8n-nodes-base.httpRequest',
+      name: 'HTTP Request',
+      position: [250, 0],
+      parameters: { 
+        url: 'https://api.example.com/data',
+        method: 'GET'
+      }
+    },
+    {
+      id: 'slack1',
+      type: 'n8n-nodes-base.slack',
+      name: 'Slack',
+      position: [500, 0],
+      parameters: {
+        channel: '#general',
+        text: 'Workflow complete!'
+      }
+    }
+  ],
+  connections: {
+    'webhook1': {
+      main: [[{ node: 'http1', type: 'main', index: 0 }]]
+    },
+    'http1': {
+      main: [[{ node: 'slack1', type: 'main', index: 0 }]]
+    }
+  }
+};
+
+console.log('🧪 Testing Workflow Tracking\n');
+console.log('Workflow has', testWorkflow.nodes.length, 'nodes');
+
+// Track the workflow
+console.log('Calling trackWorkflowCreation...');
+telemetry.trackWorkflowCreation(testWorkflow, true);
+
+console.log('Waiting for async processing...');
+
+// Wait for setImmediate to process
+setTimeout(async () => {
+  console.log('\nForcing flush...');
+  await telemetry.flush();
+  console.log('✅ Flush complete!');
+  
+  console.log('\nWorkflow should now be in the telemetry_workflows table.');
+  console.log('Check with: SELECT * FROM telemetry_workflows ORDER BY created_at DESC LIMIT 1;');
+}, 2000);

src/database/migrations/add-template-node-configs.sql

@@ -0,0 +1,59 @@
+-- Migration: Add template_node_configs table
+-- Run during `npm run rebuild` or `npm run fetch:templates`
+-- This migration is idempotent - safe to run multiple times
+
+-- Create table if it doesn't exist
+CREATE TABLE IF NOT EXISTS template_node_configs (
+  id INTEGER PRIMARY KEY,
+  node_type TEXT NOT NULL,
+  template_id INTEGER NOT NULL,
+  template_name TEXT NOT NULL,
+  template_views INTEGER DEFAULT 0,
+
+  -- Node configuration (extracted from workflow)
+  node_name TEXT,                  -- Node name in workflow (e.g., "HTTP Request")
+  parameters_json TEXT NOT NULL,   -- JSON: node.parameters
+  credentials_json TEXT,            -- JSON: node.credentials (if present)
+
+  -- Pre-calculated metadata for filtering
+  has_credentials INTEGER DEFAULT 0,
+  has_expressions INTEGER DEFAULT 0,  -- Contains {{...}} or $json/$node
+  complexity TEXT CHECK(complexity IN ('simple', 'medium', 'complex')),
+  use_cases TEXT,                   -- JSON array from template.metadata.use_cases
+
+  -- Pre-calculated ranking (1 = best, 2 = second best, etc.)
+  rank INTEGER DEFAULT 0,
+
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (template_id) REFERENCES templates(id) ON DELETE CASCADE
+);
+
+-- Create indexes if they don't exist
+CREATE INDEX IF NOT EXISTS idx_config_node_type_rank
+  ON template_node_configs(node_type, rank);
+
+CREATE INDEX IF NOT EXISTS idx_config_complexity
+  ON template_node_configs(node_type, complexity, rank);
+
+CREATE INDEX IF NOT EXISTS idx_config_auth
+  ON template_node_configs(node_type, has_credentials, rank);
+
+-- Create view if it doesn't exist
+CREATE VIEW IF NOT EXISTS ranked_node_configs AS
+SELECT
+  node_type,
+  template_name,
+  template_views,
+  parameters_json,
+  credentials_json,
+  has_credentials,
+  has_expressions,
+  complexity,
+  use_cases,
+  rank
+FROM template_node_configs
+WHERE rank <= 5  -- Top 5 per node type
+ORDER BY node_type, rank;
+
+-- Note: Actual data population is handled by the fetch-templates script
+-- This migration only creates the schema

src/database/node-repository.ts

@@ -1,6 +1,7 @@
 import { DatabaseAdapter } from './database-adapter';
 import { ParsedNode } from '../parsers/node-parser';
 import { SQLiteStorageService } from '../services/sqlite-storage-service';
+import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
 
 export class NodeRepository {
   private db: DatabaseAdapter;
@@ -50,33 +51,30 @@ export class NodeRepository {
   
   /**
    * Get node with proper JSON deserialization
+   * Automatically normalizes node type to full form for consistent lookups
    */
   getNode(nodeType: string): any {
+    // Normalize to full form first for consistent lookups
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
+
     const row = this.db.prepare(`
       SELECT * FROM nodes WHERE node_type = ?
-    `).get(nodeType) as any;
-    
+    `).get(normalizedType) as any;
+
+    // Fallback: try original type if normalization didn't help (e.g., community nodes)
+    if (!row && normalizedType !== nodeType) {
+      const originalRow = this.db.prepare(`
+        SELECT * FROM nodes WHERE node_type = ?
+      `).get(nodeType) as any;
+
+      if (originalRow) {
+        return this.parseNodeRow(originalRow);
+      }
+    }
+
     if (!row) return null;
-    
-    return {
-      nodeType: row.node_type,
-      displayName: row.display_name,
-      description: row.description,
-      category: row.category,
-      developmentStyle: row.development_style,
-      package: row.package_name,
-      isAITool: Number(row.is_ai_tool) === 1,
-      isTrigger: Number(row.is_trigger) === 1,
-      isWebhook: Number(row.is_webhook) === 1,
-      isVersioned: Number(row.is_versioned) === 1,
-      version: row.version,
-      properties: this.safeJsonParse(row.properties_schema, []),
-      operations: this.safeJsonParse(row.operations, []),
-      credentials: this.safeJsonParse(row.credentials_required, []),
-      hasDocumentation: !!row.documentation,
-      outputs: row.outputs ? this.safeJsonParse(row.outputs, null) : null,
-      outputNames: row.output_names ? this.safeJsonParse(row.output_names, null) : null
-    };
+
+    return this.parseNodeRow(row);
   }
   
   /**
@@ -248,4 +246,207 @@ export class NodeRepository {
       outputNames: row.output_names ? this.safeJsonParse(row.output_names, null) : null
     };
   }
+
+  /**
+   * Get operations for a specific node, optionally filtered by resource
+   */
+  getNodeOperations(nodeType: string, resource?: string): any[] {
+    const node = this.getNode(nodeType);
+    if (!node) return [];
+
+    const operations: any[] = [];
+
+    // Parse operations field
+    if (node.operations) {
+      if (Array.isArray(node.operations)) {
+        operations.push(...node.operations);
+      } else if (typeof node.operations === 'object') {
+        // Operations might be grouped by resource
+        if (resource && node.operations[resource]) {
+          return node.operations[resource];
+        } else {
+          // Return all operations
+          Object.values(node.operations).forEach(ops => {
+            if (Array.isArray(ops)) {
+              operations.push(...ops);
+            }
+          });
+        }
+      }
+    }
+
+    // Also check properties for operation fields
+    if (node.properties && Array.isArray(node.properties)) {
+      for (const prop of node.properties) {
+        if (prop.name === 'operation' && prop.options) {
+          // If resource is specified, filter by displayOptions
+          if (resource && prop.displayOptions?.show?.resource) {
+            const allowedResources = Array.isArray(prop.displayOptions.show.resource)
+              ? prop.displayOptions.show.resource
+              : [prop.displayOptions.show.resource];
+            if (!allowedResources.includes(resource)) {
+              continue;
+            }
+          }
+
+          // Add operations from this property
+          operations.push(...prop.options);
+        }
+      }
+    }
+
+    return operations;
+  }
+
+  /**
+   * Get all resources defined for a node
+   */
+  getNodeResources(nodeType: string): any[] {
+    const node = this.getNode(nodeType);
+    if (!node || !node.properties) return [];
+
+    const resources: any[] = [];
+
+    // Look for resource property
+    for (const prop of node.properties) {
+      if (prop.name === 'resource' && prop.options) {
+        resources.push(...prop.options);
+      }
+    }
+
+    return resources;
+  }
+
+  /**
+   * Get operations that are valid for a specific resource
+   */
+  getOperationsForResource(nodeType: string, resource: string): any[] {
+    const node = this.getNode(nodeType);
+    if (!node || !node.properties) return [];
+
+    const operations: any[] = [];
+
+    // Find operation properties that are visible for this resource
+    for (const prop of node.properties) {
+      if (prop.name === 'operation' && prop.displayOptions?.show?.resource) {
+        const allowedResources = Array.isArray(prop.displayOptions.show.resource)
+          ? prop.displayOptions.show.resource
+          : [prop.displayOptions.show.resource];
+
+        if (allowedResources.includes(resource) && prop.options) {
+          operations.push(...prop.options);
+        }
+      }
+    }
+
+    return operations;
+  }
+
+  /**
+   * Get all operations across all nodes (for analysis)
+   */
+  getAllOperations(): Map<string, any[]> {
+    const allOperations = new Map<string, any[]>();
+    const nodes = this.getAllNodes();
+
+    for (const node of nodes) {
+      const operations = this.getNodeOperations(node.nodeType);
+      if (operations.length > 0) {
+        allOperations.set(node.nodeType, operations);
+      }
+    }
+
+    return allOperations;
+  }
+
+  /**
+   * Get all resources across all nodes (for analysis)
+   */
+  getAllResources(): Map<string, any[]> {
+    const allResources = new Map<string, any[]>();
+    const nodes = this.getAllNodes();
+
+    for (const node of nodes) {
+      const resources = this.getNodeResources(node.nodeType);
+      if (resources.length > 0) {
+        allResources.set(node.nodeType, resources);
+      }
+    }
+
+    return allResources;
+  }
+
+  /**
+   * Get default values for node properties
+   */
+  getNodePropertyDefaults(nodeType: string): Record<string, any> {
+    try {
+      const node = this.getNode(nodeType);
+      if (!node || !node.properties) return {};
+
+      const defaults: Record<string, any> = {};
+
+      for (const prop of node.properties) {
+        if (prop.name && prop.default !== undefined) {
+          defaults[prop.name] = prop.default;
+        }
+      }
+
+      return defaults;
+    } catch (error) {
+      // Log error and return empty defaults rather than throwing
+      console.error(`Error getting property defaults for ${nodeType}:`, error);
+      return {};
+    }
+  }
+
+  /**
+   * Get the default operation for a specific resource
+   */
+  getDefaultOperationForResource(nodeType: string, resource?: string): string | undefined {
+    try {
+      const node = this.getNode(nodeType);
+      if (!node || !node.properties) return undefined;
+
+      // Find operation property that's visible for this resource
+      for (const prop of node.properties) {
+        if (prop.name === 'operation') {
+          // If there's a resource dependency, check if it matches
+          if (resource && prop.displayOptions?.show?.resource) {
+            // Validate displayOptions structure
+            const resourceDep = prop.displayOptions.show.resource;
+            if (!Array.isArray(resourceDep) && typeof resourceDep !== 'string') {
+              continue; // Skip malformed displayOptions
+            }
+
+            const allowedResources = Array.isArray(resourceDep)
+              ? resourceDep
+              : [resourceDep];
+
+            if (!allowedResources.includes(resource)) {
+              continue; // This operation property doesn't apply to our resource
+            }
+          }
+
+          // Return the default value if it exists
+          if (prop.default !== undefined) {
+            return prop.default;
+          }
+
+          // If no default but has options, return the first option's value
+          if (prop.options && Array.isArray(prop.options) && prop.options.length > 0) {
+            const firstOption = prop.options[0];
+            return typeof firstOption === 'string' ? firstOption : firstOption.value;
+          }
+        }
+      }
+    } catch (error) {
+      // Log error and return undefined rather than throwing
+      // This ensures validation continues even with malformed node data
+      console.error(`Error getting default operation for ${nodeType}:`, error);
+      return undefined;
+    }
+
+    return undefined;
+  }
 }

src/database/schema.sql

@@ -53,5 +53,60 @@ CREATE INDEX IF NOT EXISTS idx_template_updated ON templates(updated_at);
 CREATE INDEX IF NOT EXISTS idx_template_name ON templates(name);
 CREATE INDEX IF NOT EXISTS idx_template_metadata ON templates(metadata_generated_at);
 
+-- Pre-extracted node configurations from templates
+-- This table stores the top node configurations from popular templates
+-- Provides fast access to real-world configuration examples
+CREATE TABLE IF NOT EXISTS template_node_configs (
+  id INTEGER PRIMARY KEY,
+  node_type TEXT NOT NULL,
+  template_id INTEGER NOT NULL,
+  template_name TEXT NOT NULL,
+  template_views INTEGER DEFAULT 0,
+
+  -- Node configuration (extracted from workflow)
+  node_name TEXT,                  -- Node name in workflow (e.g., "HTTP Request")
+  parameters_json TEXT NOT NULL,   -- JSON: node.parameters
+  credentials_json TEXT,            -- JSON: node.credentials (if present)
+
+  -- Pre-calculated metadata for filtering
+  has_credentials INTEGER DEFAULT 0,
+  has_expressions INTEGER DEFAULT 0,  -- Contains {{...}} or $json/$node
+  complexity TEXT CHECK(complexity IN ('simple', 'medium', 'complex')),
+  use_cases TEXT,                   -- JSON array from template.metadata.use_cases
+
+  -- Pre-calculated ranking (1 = best, 2 = second best, etc.)
+  rank INTEGER DEFAULT 0,
+
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (template_id) REFERENCES templates(id) ON DELETE CASCADE
+);
+
+-- Indexes for fast queries
+CREATE INDEX IF NOT EXISTS idx_config_node_type_rank
+  ON template_node_configs(node_type, rank);
+
+CREATE INDEX IF NOT EXISTS idx_config_complexity
+  ON template_node_configs(node_type, complexity, rank);
+
+CREATE INDEX IF NOT EXISTS idx_config_auth
+  ON template_node_configs(node_type, has_credentials, rank);
+
+-- View for easy querying of top configs
+CREATE VIEW IF NOT EXISTS ranked_node_configs AS
+SELECT
+  node_type,
+  template_name,
+  template_views,
+  parameters_json,
+  credentials_json,
+  has_credentials,
+  has_expressions,
+  complexity,
+  use_cases,
+  rank
+FROM template_node_configs
+WHERE rank <= 5  -- Top 5 per node type
+ORDER BY node_type, rank;
+
 -- Note: FTS5 tables are created conditionally at runtime if FTS5 is supported
 -- See template-repository.ts initializeFTS5() method

src/errors/validation-service-error.ts

@@ -0,0 +1,53 @@
+/**
+ * Custom error class for validation service failures
+ */
+export class ValidationServiceError extends Error {
+  constructor(
+    message: string,
+    public readonly nodeType?: string,
+    public readonly property?: string,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = 'ValidationServiceError';
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationServiceError);
+    }
+  }
+
+  /**
+   * Create error for JSON parsing failure
+   */
+  static jsonParseError(nodeType: string, cause: Error): ValidationServiceError {
+    return new ValidationServiceError(
+      `Failed to parse JSON data for node ${nodeType}`,
+      nodeType,
+      undefined,
+      cause
+    );
+  }
+
+  /**
+   * Create error for node not found
+   */
+  static nodeNotFound(nodeType: string): ValidationServiceError {
+    return new ValidationServiceError(
+      `Node type ${nodeType} not found in repository`,
+      nodeType
+    );
+  }
+
+  /**
+   * Create error for critical data extraction failure
+   */
+  static dataExtractionError(nodeType: string, dataType: string, cause?: Error): ValidationServiceError {
+    return new ValidationServiceError(
+      `Failed to extract ${dataType} for node ${nodeType}`,
+      nodeType,
+      dataType,
+      cause
+    );
+  }
+}

src/mcp-tools-engine.ts

@@ -89,10 +89,6 @@ export class MCPEngine {
     return this.repository.searchNodeProperties(args.nodeType, args.query, args.maxResults || 20);
   }
 
-  async getNodeForTask(args: any) {
-    return TaskTemplates.getTaskTemplate(args.task);
-  }
-
   async listAITools(args: any) {
     return this.repository.getAIToolNodes();
   }

src/mcp/handlers-n8n-manager.ts

@@ -6,7 +6,9 @@ import {
   WorkflowConnection,
   ExecutionStatus,
   WebhookRequest,
-  McpToolResponse
+  McpToolResponse,
+  ExecutionFilterOptions,
+  ExecutionMode
 } from '../types/n8n-api';
 import {
   validateWorkflowStructure,
@@ -16,7 +18,9 @@ import {
 import {
   N8nApiError,
   N8nNotFoundError,
-  getUserFriendlyErrorMessage
+  getUserFriendlyErrorMessage,
+  formatExecutionError,
+  formatNoExecutionError
 } from '../utils/n8n-errors';
 import { logger } from '../utils/logger';
 import { z } from 'zod';
@@ -24,6 +28,11 @@ import { WorkflowValidator } from '../services/workflow-validator';
 import { EnhancedConfigValidator } from '../services/enhanced-config-validator';
 import { NodeRepository } from '../database/node-repository';
 import { InstanceContext, validateInstanceContext } from '../types/instance-context';
+import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
+import { WorkflowAutoFixer, AutoFixConfig } from '../services/workflow-auto-fixer';
+import { ExpressionFormatValidator } from '../services/expression-format-validator';
+import { handleUpdatePartialWorkflow } from './handlers-workflow-diff';
+import { telemetry } from '../telemetry';
 import {
   createCacheKey,
   createInstanceCache,
@@ -32,6 +41,7 @@ import {
   withRetry,
   getCacheStatistics
 } from '../utils/cache-utils';
+import { processExecution } from '../services/execution-processor';
 
 // Singleton n8n API client instance (backward compatibility)
 let defaultApiClient: N8nApiClient | null = null;
@@ -236,6 +246,20 @@ const validateWorkflowSchema = z.object({
   }).optional(),
 });
 
+const autofixWorkflowSchema = z.object({
+  id: z.string(),
+  applyFixes: z.boolean().optional().default(false),
+  fixTypes: z.array(z.enum([
+    'expression-format',
+    'typeversion-correction',
+    'error-output-config',
+    'node-type-correction',
+    'webhook-missing-path'
+  ])).optional(),
+  confidenceThreshold: z.enum(['high', 'medium', 'low']).optional().default('medium'),
+  maxFixes: z.number().optional().default(50)
+});
+
 const triggerWebhookSchema = z.object({
   webhookUrl: z.string().url(),
   httpMethod: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional(),
@@ -259,20 +283,52 @@ export async function handleCreateWorkflow(args: unknown, context?: InstanceCont
   try {
     const client = ensureApiConfigured(context);
     const input = createWorkflowSchema.parse(args);
-    
-    // Validate workflow structure
+
+    // Proactively detect SHORT form node types (common mistake)
+    const shortFormErrors: string[] = [];
+    input.nodes?.forEach((node: any, index: number) => {
+      if (node.type?.startsWith('nodes-base.') || node.type?.startsWith('nodes-langchain.')) {
+        const fullForm = node.type.startsWith('nodes-base.')
+          ? node.type.replace('nodes-base.', 'n8n-nodes-base.')
+          : node.type.replace('nodes-langchain.', '@n8n/n8n-nodes-langchain.');
+        shortFormErrors.push(
+          `Node ${index} ("${node.name}") uses SHORT form "${node.type}". ` +
+          `The n8n API requires FULL form. Change to "${fullForm}"`
+        );
+      }
+    });
+
+    if (shortFormErrors.length > 0) {
+      telemetry.trackWorkflowCreation(input, false);
+      return {
+        success: false,
+        error: 'Node type format error: n8n API requires FULL form node types',
+        details: {
+          errors: shortFormErrors,
+          hint: 'Use n8n-nodes-base.* instead of nodes-base.* for standard nodes'
+        }
+      };
+    }
+
+    // Validate workflow structure (n8n API expects FULL form: n8n-nodes-base.*)
     const errors = validateWorkflowStructure(input);
     if (errors.length > 0) {
+      // Track validation failure
+      telemetry.trackWorkflowCreation(input, false);
+
       return {
         success: false,
         error: 'Workflow validation failed',
         details: { errors }
       };
     }
-    
-    // Create workflow
+
+    // Create workflow (n8n API expects node types in FULL form)
     const workflow = await client.createWorkflow(input);
-    
+
+    // Track successful workflow creation
+    telemetry.trackWorkflowCreation(workflow, true);
+
     return {
       success: true,
       data: workflow,
@@ -493,20 +549,17 @@ export async function handleUpdateWorkflow(args: unknown, context?: InstanceCont
     const client = ensureApiConfigured(context);
     const input = updateWorkflowSchema.parse(args);
     const { id, ...updateData } = input;
-    
+
     // If nodes/connections are being updated, validate the structure
     if (updateData.nodes || updateData.connections) {
-      // Fetch current workflow if only partial update
-      let fullWorkflow = updateData as Partial<Workflow>;
-      
-      if (!updateData.nodes || !updateData.connections) {
-        const current = await client.getWorkflow(id);
-        fullWorkflow = {
-          ...current,
-          ...updateData
-        };
-      }
-      
+      // Always fetch current workflow for validation (need all fields like name)
+      const current = await client.getWorkflow(id);
+      const fullWorkflow = {
+        ...current,
+        ...updateData
+      };
+
+      // Validate workflow structure (n8n API expects FULL form: n8n-nodes-base.*)
       const errors = validateWorkflowStructure(fullWorkflow);
       if (errors.length > 0) {
         return {
@@ -554,11 +607,12 @@ export async function handleDeleteWorkflow(args: unknown, context?: InstanceCont
   try {
     const client = ensureApiConfigured(context);
     const { id } = z.object({ id: z.string() }).parse(args);
-    
-    await client.deleteWorkflow(id);
-    
+
+    const deleted = await client.deleteWorkflow(id);
+
     return {
       success: true,
+      data: deleted,
       message: `Workflow ${id} deleted successfully`
     };
   } catch (error) {
@@ -589,12 +643,17 @@ export async function handleListWorkflows(args: unknown, context?: InstanceConte
   try {
     const client = ensureApiConfigured(context);
     const input = listWorkflowsSchema.parse(args || {});
-    
+
+    // Convert tags array to comma-separated string (n8n API format)
+    const tagsParam = input.tags && input.tags.length > 0
+      ? input.tags.join(',')
+      : undefined;
+
     const response = await client.listWorkflows({
       limit: input.limit || 100,
       cursor: input.cursor,
       active: input.active,
-      tags: input.tags,
+      tags: tagsParam as any,  // API expects string, not array
       projectId: input.projectId,
       excludePinnedData: input.excludePinnedData ?? true
     });
@@ -707,7 +766,12 @@ export async function handleValidateWorkflow(
     if (validationResult.suggestions.length > 0) {
       response.suggestions = validationResult.suggestions;
     }
-    
+
+    // Track successfully validated workflows in telemetry
+    if (validationResult.valid) {
+      telemetry.trackWorkflowCreation(workflow, true);
+    }
+
     return {
       success: true,
       data: response
@@ -736,13 +800,181 @@ export async function handleValidateWorkflow(
   }
 }
 
+export async function handleAutofixWorkflow(
+  args: unknown,
+  repository: NodeRepository,
+  context?: InstanceContext
+): Promise<McpToolResponse> {
+  try {
+    const client = ensureApiConfigured(context);
+    const input = autofixWorkflowSchema.parse(args);
+
+    // First, fetch the workflow from n8n
+    const workflowResponse = await handleGetWorkflow({ id: input.id }, context);
+
+    if (!workflowResponse.success) {
+      return workflowResponse; // Return the error from fetching
+    }
+
+    const workflow = workflowResponse.data as Workflow;
+
+    // Create validator instance using the provided repository
+    const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+
+    // Run validation to identify issues
+    const validationResult = await validator.validateWorkflow(workflow, {
+      validateNodes: true,
+      validateConnections: true,
+      validateExpressions: true,
+      profile: 'ai-friendly'
+    });
+
+    // Check for expression format issues
+    const allFormatIssues: any[] = [];
+    for (const node of workflow.nodes) {
+      const formatContext = {
+        nodeType: node.type,
+        nodeName: node.name,
+        nodeId: node.id
+      };
+
+      const nodeFormatIssues = ExpressionFormatValidator.validateNodeParameters(
+        node.parameters,
+        formatContext
+      );
+
+      // Add node information to each format issue
+      const enrichedIssues = nodeFormatIssues.map(issue => ({
+        ...issue,
+        nodeName: node.name,
+        nodeId: node.id
+      }));
+
+      allFormatIssues.push(...enrichedIssues);
+    }
+
+    // Generate fixes using WorkflowAutoFixer
+    const autoFixer = new WorkflowAutoFixer(repository);
+    const fixResult = autoFixer.generateFixes(
+      workflow,
+      validationResult,
+      allFormatIssues,
+      {
+        applyFixes: input.applyFixes,
+        fixTypes: input.fixTypes,
+        confidenceThreshold: input.confidenceThreshold,
+        maxFixes: input.maxFixes
+      }
+    );
+
+    // If no fixes available
+    if (fixResult.fixes.length === 0) {
+      return {
+        success: true,
+        data: {
+          workflowId: workflow.id,
+          workflowName: workflow.name,
+          message: 'No automatic fixes available for this workflow',
+          validationSummary: {
+            errors: validationResult.errors.length,
+            warnings: validationResult.warnings.length
+          }
+        }
+      };
+    }
+
+    // If preview mode (applyFixes = false)
+    if (!input.applyFixes) {
+      return {
+        success: true,
+        data: {
+          workflowId: workflow.id,
+          workflowName: workflow.name,
+          preview: true,
+          fixesAvailable: fixResult.fixes.length,
+          fixes: fixResult.fixes,
+          summary: fixResult.summary,
+          stats: fixResult.stats,
+          message: `${fixResult.fixes.length} fixes available. Set applyFixes=true to apply them.`
+        }
+      };
+    }
+
+    // Apply fixes using the diff engine
+    if (fixResult.operations.length > 0) {
+      const updateResult = await handleUpdatePartialWorkflow(
+        {
+          id: workflow.id,
+          operations: fixResult.operations
+        },
+        context
+      );
+
+      if (!updateResult.success) {
+        return {
+          success: false,
+          error: 'Failed to apply fixes',
+          details: {
+            fixes: fixResult.fixes,
+            updateError: updateResult.error
+          }
+        };
+      }
+
+      return {
+        success: true,
+        data: {
+          workflowId: workflow.id,
+          workflowName: workflow.name,
+          fixesApplied: fixResult.fixes.length,
+          fixes: fixResult.fixes,
+          summary: fixResult.summary,
+          stats: fixResult.stats,
+          message: `Successfully applied ${fixResult.fixes.length} fixes to workflow "${workflow.name}"`
+        }
+      };
+    }
+
+    return {
+      success: true,
+      data: {
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+        message: 'No fixes needed'
+      }
+    };
+
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: 'Invalid input',
+        details: { errors: error.errors }
+      };
+    }
+
+    if (error instanceof N8nApiError) {
+      return {
+        success: false,
+        error: getUserFriendlyErrorMessage(error),
+        code: error.code
+      };
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred'
+    };
+  }
+}
+
 // Execution Management Handlers
 
 export async function handleTriggerWebhookWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
   try {
     const client = ensureApiConfigured(context);
     const input = triggerWebhookSchema.parse(args);
-    
+
     const webhookRequest: WebhookRequest = {
       webhookUrl: input.webhookUrl,
       httpMethod: input.httpMethod || 'POST',
@@ -750,9 +982,9 @@ export async function handleTriggerWebhookWorkflow(args: unknown, context?: Inst
       headers: input.headers,
       waitForResponse: input.waitForResponse ?? true
     };
-    
+
     const response = await client.triggerWebhook(webhookRequest);
-    
+
     return {
       success: true,
       data: response,
@@ -766,8 +998,35 @@ export async function handleTriggerWebhookWorkflow(args: unknown, context?: Inst
         details: { errors: error.errors }
       };
     }
-    
+
     if (error instanceof N8nApiError) {
+      // Try to extract execution context from error response
+      const errorData = error.details as any;
+      const executionId = errorData?.executionId || errorData?.id || errorData?.execution?.id;
+      const workflowId = errorData?.workflowId || errorData?.workflow?.id;
+
+      // If we have execution ID, provide specific guidance with n8n_get_execution
+      if (executionId) {
+        return {
+          success: false,
+          error: formatExecutionError(executionId, workflowId),
+          code: error.code,
+          executionId,
+          workflowId: workflowId || undefined
+        };
+      }
+
+      // No execution ID available - workflow likely didn't start
+      // Provide guidance to check recent executions
+      if (error.code === 'SERVER_ERROR' || error.statusCode && error.statusCode >= 500) {
+        return {
+          success: false,
+          error: formatNoExecutionError(),
+          code: error.code
+        };
+      }
+
+      // For other errors (auth, validation, etc), use standard message
       return {
         success: false,
         error: getUserFriendlyErrorMessage(error),
@@ -775,7 +1034,7 @@ export async function handleTriggerWebhookWorkflow(args: unknown, context?: Inst
         details: error.details as Record<string, unknown> | undefined
       };
     }
-    
+
     return {
       success: false,
       error: error instanceof Error ? error.message : 'Unknown error occurred'
@@ -786,16 +1045,72 @@ export async function handleTriggerWebhookWorkflow(args: unknown, context?: Inst
 export async function handleGetExecution(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
   try {
     const client = ensureApiConfigured(context);
-    const { id, includeData } = z.object({ 
+
+    // Parse and validate input with new parameters
+    const schema = z.object({
       id: z.string(),
+      // New filtering parameters
+      mode: z.enum(['preview', 'summary', 'filtered', 'full']).optional(),
+      nodeNames: z.array(z.string()).optional(),
+      itemsLimit: z.number().optional(),
+      includeInputData: z.boolean().optional(),
+      // Legacy parameter (backward compatibility)
       includeData: z.boolean().optional()
-    }).parse(args);
-    
-    const execution = await client.getExecution(id, includeData || false);
-    
+    });
+
+    const params = schema.parse(args);
+    const { id, mode, nodeNames, itemsLimit, includeInputData, includeData } = params;
+
+    /**
+     * Map legacy includeData parameter to mode for backward compatibility
+     *
+     * Legacy behavior:
+     * - includeData: undefined -> minimal execution summary (no data)
+     * - includeData: false -> minimal execution summary (no data)
+     * - includeData: true -> full execution data
+     *
+     * New behavior mapping:
+     * - includeData: undefined -> no mode (minimal)
+     * - includeData: false -> no mode (minimal)
+     * - includeData: true -> mode: 'summary' (2 items per node, not full)
+     *
+     * Note: Legacy true behavior returned ALL data, which could exceed token limits.
+     * New behavior caps at 2 items for safety. Users can use mode: 'full' for old behavior.
+     */
+    let effectiveMode = mode;
+    if (!effectiveMode && includeData !== undefined) {
+      effectiveMode = includeData ? 'summary' : undefined;
+    }
+
+    // Determine if we need to fetch full data from API
+    // We fetch full data if any mode is specified (including preview) or legacy includeData is true
+    // Preview mode needs the data to analyze structure and generate recommendations
+    const fetchFullData = effectiveMode !== undefined || includeData === true;
+
+    // Fetch execution from n8n API
+    const execution = await client.getExecution(id, fetchFullData);
+
+    // If no filtering options specified, return original execution (backward compatibility)
+    if (!effectiveMode && !nodeNames && itemsLimit === undefined) {
+      return {
+        success: true,
+        data: execution
+      };
+    }
+
+    // Apply filtering using ExecutionProcessor
+    const filterOptions: ExecutionFilterOptions = {
+      mode: effectiveMode,
+      nodeNames,
+      itemsLimit,
+      includeInputData
+    };
+
+    const processedExecution = processExecution(execution, filterOptions);
+
     return {
       success: true,
-      data: execution
+      data: processedExecution
     };
   } catch (error) {
     if (error instanceof z.ZodError) {
@@ -805,7 +1120,7 @@ export async function handleGetExecution(args: unknown, context?: InstanceContex
         details: { errors: error.errors }
       };
     }
-    
+
     if (error instanceof N8nApiError) {
       return {
         success: false,
@@ -813,7 +1128,7 @@ export async function handleGetExecution(args: unknown, context?: InstanceContex
         code: error.code
       };
     }
-    
+
     return {
       success: false,
       error: error instanceof Error ? error.message : 'Unknown error occurred'
@@ -964,7 +1279,8 @@ export async function handleListAvailableTools(context?: InstanceContext): Promi
         { name: 'n8n_update_workflow', description: 'Update existing workflows' },
         { name: 'n8n_delete_workflow', description: 'Delete workflows' },
         { name: 'n8n_list_workflows', description: 'List workflows with filters' },
-        { name: 'n8n_validate_workflow', description: 'Validate workflow from n8n instance' }
+        { name: 'n8n_validate_workflow', description: 'Validate workflow from n8n instance' },
+        { name: 'n8n_autofix_workflow', description: 'Automatically fix common workflow errors' }
       ]
     },
     {

src/mcp/handlers-workflow-diff.ts

@@ -31,12 +31,17 @@ const workflowDiffSchema = z.object({
     targetInput: z.string().optional(),
     sourceIndex: z.number().optional(),
     targetIndex: z.number().optional(),
+    ignoreErrors: z.boolean().optional(),
+    // Connection cleanup operations
+    dryRun: z.boolean().optional(),
+    connections: z.any().optional(),
     // Metadata operations
     settings: z.any().optional(),
     name: z.string().optional(),
     tag: z.string().optional(),
   })),
   validateOnly: z.boolean().optional(),
+  continueOnError: z.boolean().optional(),
 });
 
 export async function handleUpdatePartialWorkflow(args: unknown, context?: InstanceContext): Promise<McpToolResponse> {
@@ -80,17 +85,28 @@ export async function handleUpdatePartialWorkflow(args: unknown, context?: Insta
     
     // Apply diff operations
     const diffEngine = new WorkflowDiffEngine();
-    const diffResult = await diffEngine.applyDiff(workflow, input as WorkflowDiffRequest);
-    
+    const diffRequest = input as WorkflowDiffRequest;
+    const diffResult = await diffEngine.applyDiff(workflow, diffRequest);
+
+    // Check if this is a complete failure or partial success in continueOnError mode
     if (!diffResult.success) {
-      return {
-        success: false,
-        error: 'Failed to apply diff operations',
-        details: {
-          errors: diffResult.errors,
-          operationsApplied: diffResult.operationsApplied
-        }
-      };
+      // In continueOnError mode, partial success is still valuable
+      if (diffRequest.continueOnError && diffResult.workflow && diffResult.operationsApplied && diffResult.operationsApplied > 0) {
+        logger.info(`continueOnError mode: Applying ${diffResult.operationsApplied} successful operations despite ${diffResult.failed?.length || 0} failures`);
+        // Continue to update workflow with partial changes
+      } else {
+        // Complete failure - return error
+        return {
+          success: false,
+          error: 'Failed to apply diff operations',
+          details: {
+            errors: diffResult.errors,
+            operationsApplied: diffResult.operationsApplied,
+            applied: diffResult.applied,
+            failed: diffResult.failed
+          }
+        };
+      }
     }
     
     // If validateOnly, return validation result
@@ -116,7 +132,10 @@ export async function handleUpdatePartialWorkflow(args: unknown, context?: Insta
         details: {
           operationsApplied: diffResult.operationsApplied,
           workflowId: updatedWorkflow.id,
-          workflowName: updatedWorkflow.name
+          workflowName: updatedWorkflow.name,
+          applied: diffResult.applied,
+          failed: diffResult.failed,
+          errors: diffResult.errors
         }
       };
     } catch (error) {

src/mcp/index.ts

@@ -2,6 +2,7 @@
 
 import { N8NDocumentationMCPServer } from './server';
 import { logger } from '../utils/logger';
+import { TelemetryConfigManager } from '../telemetry/config-manager';
 
 // Add error details to stderr for Claude Desktop debugging
 process.on('uncaughtException', (error) => {
@@ -21,8 +22,42 @@ process.on('unhandledRejection', (reason, promise) => {
 });
 
 async function main() {
+  // Handle telemetry CLI commands
+  const args = process.argv.slice(2);
+  if (args.length > 0 && args[0] === 'telemetry') {
+    const telemetryConfig = TelemetryConfigManager.getInstance();
+    const action = args[1];
+
+    switch (action) {
+      case 'enable':
+        telemetryConfig.enable();
+        process.exit(0);
+        break;
+      case 'disable':
+        telemetryConfig.disable();
+        process.exit(0);
+        break;
+      case 'status':
+        console.log(telemetryConfig.getStatus());
+        process.exit(0);
+        break;
+      default:
+        console.log(`
+Usage: n8n-mcp telemetry [command]
+
+Commands:
+  enable   Enable anonymous telemetry
+  disable  Disable anonymous telemetry
+  status   Show current telemetry status
+
+Learn more: https://github.com/czlonkowski/n8n-mcp/blob/main/PRIVACY.md
+`);
+        process.exit(args[1] ? 1 : 0);
+    }
+  }
+
   const mode = process.env.MCP_MODE || 'stdio';
-  
+
   try {
     // Only show debug messages in HTTP mode to avoid corrupting stdio communication
     if (mode === 'http') {

src/mcp/server.ts

@@ -27,7 +27,8 @@ import * as n8nHandlers from './handlers-n8n-manager';
 import { handleUpdatePartialWorkflow } from './handlers-workflow-diff';
 import { getToolDocumentation, getToolsOverview } from './tools-documentation';
 import { PROJECT_VERSION } from '../utils/version';
-import { normalizeNodeType, getNodeTypeAlternatives, getWorkflowNodeType } from '../utils/node-utils';
+import { getNodeTypeAlternatives, getWorkflowNodeType } from '../utils/node-utils';
+import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
 import { ToolValidation, Validator, ValidationError } from '../utils/validation-schemas';
 import {
   negotiateProtocolVersion,
@@ -35,6 +36,7 @@ import {
   STANDARD_PROTOCOL_VERSION
 } from '../utils/protocol-version';
 import { InstanceContext } from '../types/instance-context';
+import { telemetry } from '../telemetry';
 
 interface NodeRow {
   node_type: string;
@@ -63,6 +65,8 @@ export class N8NDocumentationMCPServer {
   private cache = new SimpleCache();
   private clientInfo: any = null;
   private instanceContext?: InstanceContext;
+  private previousTool: string | null = null;
+  private previousToolTimestamp: number = Date.now();
 
   constructor(instanceContext?: InstanceContext) {
     this.instanceContext = instanceContext;
@@ -134,6 +138,10 @@ export class N8NDocumentationMCPServer {
       
       this.repository = new NodeRepository(this.db);
       this.templateService = new TemplateService(this.db);
+
+      // Initialize similarity services for enhanced validation
+      EnhancedConfigValidator.initializeSimilarityServices(this.repository);
+
       logger.info(`Initialized database from: ${dbPath}`);
     } catch (error) {
       logger.error('Failed to initialize database:', error);
@@ -176,7 +184,10 @@ export class N8NDocumentationMCPServer {
         clientCapabilities,
         clientInfo
       });
-      
+
+      // Track session start
+      telemetry.trackSessionStart();
+
       // Store client info for later use
       this.clientInfo = clientInfo;
       
@@ -318,8 +329,23 @@ export class N8NDocumentationMCPServer {
       
       try {
         logger.debug(`Executing tool: ${name}`, { args: processedArgs });
+        const startTime = Date.now();
         const result = await this.executeTool(name, processedArgs);
+        const duration = Date.now() - startTime;
         logger.debug(`Tool ${name} executed successfully`);
+
+        // Track tool usage and sequence
+        telemetry.trackToolUsage(name, true, duration);
+
+        // Track tool sequence if there was a previous tool
+        if (this.previousTool) {
+          const timeDelta = Date.now() - this.previousToolTimestamp;
+          telemetry.trackToolSequence(this.previousTool, name, timeDelta);
+        }
+
+        // Update previous tool tracking
+        this.previousTool = name;
+        this.previousToolTimestamp = Date.now();
         
         // Ensure the result is properly formatted for MCP
         let responseText: string;
@@ -366,7 +392,26 @@ export class N8NDocumentationMCPServer {
       } catch (error) {
         logger.error(`Error executing tool ${name}`, error);
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        
+
+        // Track tool error
+        telemetry.trackToolUsage(name, false);
+        telemetry.trackError(
+          error instanceof Error ? error.constructor.name : 'UnknownError',
+          `tool_execution`,
+          name,
+          errorMessage
+        );
+
+        // Track tool sequence even for errors
+        if (this.previousTool) {
+          const timeDelta = Date.now() - this.previousToolTimestamp;
+          telemetry.trackToolSequence(this.previousTool, name, timeDelta);
+        }
+
+        // Update previous tool tracking (even for failed tools)
+        this.previousTool = name;
+        this.previousToolTimestamp = Date.now();
+
         // Provide more helpful error messages for common n8n issues
         let helpfulMessage = `Error executing tool ${name}: ${errorMessage}`;
         
@@ -516,6 +561,7 @@ export class N8NDocumentationMCPServer {
       case 'n8n_update_full_workflow':
       case 'n8n_delete_workflow':
       case 'n8n_validate_workflow':
+      case 'n8n_autofix_workflow':
       case 'n8n_get_execution':
       case 'n8n_delete_execution':
         validationResult = ToolValidation.validateWorkflowId(args);
@@ -668,7 +714,7 @@ export class N8NDocumentationMCPServer {
         this.validateToolParams(name, args, ['query']);
         // Convert limit to number if provided, otherwise use default
         const limit = args.limit !== undefined ? Number(args.limit) || 20 : 20;
-        return this.searchNodes(args.query, limit, { mode: args.mode });
+        return this.searchNodes(args.query, limit, { mode: args.mode, includeExamples: args.includeExamples });
       case 'list_ai_tools':
         // No required parameters
         return this.listAITools();
@@ -680,14 +726,11 @@ export class N8NDocumentationMCPServer {
         return this.getDatabaseStatistics();
       case 'get_node_essentials':
         this.validateToolParams(name, args, ['nodeType']);
-        return this.getNodeEssentials(args.nodeType);
+        return this.getNodeEssentials(args.nodeType, args.includeExamples);
       case 'search_node_properties':
         this.validateToolParams(name, args, ['nodeType', 'query']);
         const maxResults = args.maxResults !== undefined ? Number(args.maxResults) || 20 : 20;
         return this.searchNodeProperties(args.nodeType, args.query, maxResults);
-      case 'get_node_for_task':
-        this.validateToolParams(name, args, ['task']);
-        return this.getNodeForTask(args.task);
       case 'list_tasks':
         // No required parameters
         return this.listTasks(args.category);
@@ -828,6 +871,11 @@ export class N8NDocumentationMCPServer {
         await this.ensureInitialized();
         if (!this.repository) throw new Error('Repository not initialized');
         return n8nHandlers.handleValidateWorkflow(args, this.repository, this.instanceContext);
+      case 'n8n_autofix_workflow':
+        this.validateToolParams(name, args, ['id']);
+        await this.ensureInitialized();
+        if (!this.repository) throw new Error('Repository not initialized');
+        return n8nHandlers.handleAutofixWorkflow(args, this.repository, this.instanceContext);
       case 'n8n_trigger_webhook_workflow':
         this.validateToolParams(name, args, ['webhookUrl']);
         return n8nHandlers.handleTriggerWebhookWorkflow(args, this.instanceContext);
@@ -917,9 +965,9 @@ export class N8NDocumentationMCPServer {
   private async getNodeInfo(nodeType: string): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
-    // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+
+    // First try with normalized type (repository will also normalize internally)
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -944,47 +992,48 @@ export class N8NDocumentationMCPServer {
       throw new Error(`Node ${nodeType} not found`);
     }
     
-    // Add AI tool capabilities information
+    // Add AI tool capabilities information with null safety
     const aiToolCapabilities = {
       canBeUsedAsTool: true, // Any node can be used as a tool in n8n
-      hasUsableAsToolProperty: node.isAITool,
-      requiresEnvironmentVariable: !node.isAITool && node.package !== 'n8n-nodes-base',
+      hasUsableAsToolProperty: node.isAITool ?? false,
+      requiresEnvironmentVariable: !(node.isAITool ?? false) && node.package !== 'n8n-nodes-base',
       toolConnectionType: 'ai_tool',
       commonToolUseCases: this.getCommonAIToolUseCases(node.nodeType),
-      environmentRequirement: node.package !== 'n8n-nodes-base' ? 
-        'N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true' : 
+      environmentRequirement: node.package && node.package !== 'n8n-nodes-base' ?
+        'N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true' :
         null
     };
-    
-    // Process outputs to provide clear mapping
+
+    // Process outputs to provide clear mapping with null safety
     let outputs = undefined;
-    if (node.outputNames && node.outputNames.length > 0) {
+    if (node.outputNames && Array.isArray(node.outputNames) && node.outputNames.length > 0) {
       outputs = node.outputNames.map((name: string, index: number) => {
         // Special handling for loop nodes like SplitInBatches
         const descriptions = this.getOutputDescriptions(node.nodeType, name, index);
         return {
           index,
           name,
-          description: descriptions.description,
-          connectionGuidance: descriptions.connectionGuidance
+          description: descriptions?.description ?? '',
+          connectionGuidance: descriptions?.connectionGuidance ?? ''
         };
       });
     }
-    
+
     return {
       ...node,
-      workflowNodeType: getWorkflowNodeType(node.package, node.nodeType),
+      workflowNodeType: getWorkflowNodeType(node.package ?? 'n8n-nodes-base', node.nodeType),
       aiToolCapabilities,
       outputs
     };
   }
 
   private async searchNodes(
-    query: string, 
+    query: string,
     limit: number = 20,
-    options?: { 
+    options?: {
       mode?: 'OR' | 'AND' | 'FUZZY';
       includeSource?: boolean;
+      includeExamples?: boolean;
     }
   ): Promise<any> {
     await this.ensureInitialized();
@@ -1010,16 +1059,23 @@ export class N8NDocumentationMCPServer {
     
     if (ftsExists) {
       // Use FTS5 search with normalized query
-      return this.searchNodesFTS(normalizedQuery, limit, searchMode);
+      logger.debug(`Using FTS5 search with includeExamples=${options?.includeExamples}`);
+      return this.searchNodesFTS(normalizedQuery, limit, searchMode, options);
     } else {
       // Fallback to LIKE search with normalized query
-      return this.searchNodesLIKE(normalizedQuery, limit);
+      logger.debug('Using LIKE search (no FTS5)');
+      return this.searchNodesLIKE(normalizedQuery, limit, options);
     }
   }
-  
-  private async searchNodesFTS(query: string, limit: number, mode: 'OR' | 'AND' | 'FUZZY'): Promise<any> {
+
+  private async searchNodesFTS(
+    query: string,
+    limit: number,
+    mode: 'OR' | 'AND' | 'FUZZY',
+    options?: { includeSource?: boolean; includeExamples?: boolean; }
+  ): Promise<any> {
     if (!this.db) throw new Error('Database not initialized');
-    
+
     // Clean and prepare the query
     const cleanedQuery = query.trim();
     if (!cleanedQuery) {
@@ -1118,12 +1174,43 @@ export class N8NDocumentationMCPServer {
         })),
         totalCount: scoredNodes.length
       };
-      
+
       // Only include mode if it's not the default
       if (mode !== 'OR') {
         result.mode = mode;
       }
-      
+
+      // Add examples if requested
+      if (options && options.includeExamples) {
+        try {
+          for (const nodeResult of result.results) {
+            const examples = this.db!.prepare(`
+              SELECT
+                parameters_json,
+                template_name,
+                template_views
+              FROM template_node_configs
+              WHERE node_type = ?
+              ORDER BY rank
+              LIMIT 2
+            `).all(nodeResult.workflowNodeType) as any[];
+
+            if (examples.length > 0) {
+              nodeResult.examples = examples.map((ex: any) => ({
+                configuration: JSON.parse(ex.parameters_json),
+                template: ex.template_name,
+                views: ex.template_views
+              }));
+            }
+          }
+        } catch (error: any) {
+          logger.error(`Failed to add examples:`, error);
+        }
+      }
+
+      // Track search query telemetry
+      telemetry.trackSearchQuery(query, scoredNodes.length, mode ?? 'OR');
+
       return result;
       
     } catch (error: any) {
@@ -1136,6 +1223,10 @@ export class N8NDocumentationMCPServer {
         
         // For problematic queries, use LIKE search with mode info
         const likeResult = await this.searchNodesLIKE(query, limit);
+
+        // Track search query telemetry for fallback
+        telemetry.trackSearchQuery(query, likeResult.results?.length ?? 0, `${mode}_LIKE_FALLBACK`);
+
         return {
           ...likeResult,
           mode
@@ -1293,24 +1384,28 @@ export class N8NDocumentationMCPServer {
     return dp[m][n];
   }
   
-  private async searchNodesLIKE(query: string, limit: number): Promise<any> {
+  private async searchNodesLIKE(
+    query: string,
+    limit: number,
+    options?: { includeSource?: boolean; includeExamples?: boolean; }
+  ): Promise<any> {
     if (!this.db) throw new Error('Database not initialized');
-    
+
     // This is the existing LIKE-based implementation
     // Handle exact phrase searches with quotes
     if (query.startsWith('"') && query.endsWith('"')) {
       const exactPhrase = query.slice(1, -1);
       const nodes = this.db!.prepare(`
-        SELECT * FROM nodes 
+        SELECT * FROM nodes
         WHERE node_type LIKE ? OR display_name LIKE ? OR description LIKE ?
         LIMIT ?
       `).all(`%${exactPhrase}%`, `%${exactPhrase}%`, `%${exactPhrase}%`, limit * 3) as NodeRow[];
-      
+
       // Apply relevance ranking for exact phrase search
       const rankedNodes = this.rankSearchResults(nodes, exactPhrase, limit);
-      
-      return { 
-        query, 
+
+      const result: any = {
+        query,
         results: rankedNodes.map(node => ({
           nodeType: node.node_type,
           workflowNodeType: getWorkflowNodeType(node.package_name, node.node_type),
@@ -1318,9 +1413,39 @@ export class N8NDocumentationMCPServer {
           description: node.description,
           category: node.category,
           package: node.package_name
-        })), 
-        totalCount: rankedNodes.length 
+        })),
+        totalCount: rankedNodes.length
       };
+
+      // Add examples if requested
+      if (options?.includeExamples) {
+        for (const nodeResult of result.results) {
+          try {
+            const examples = this.db!.prepare(`
+              SELECT
+                parameters_json,
+                template_name,
+                template_views
+              FROM template_node_configs
+              WHERE node_type = ?
+              ORDER BY rank
+              LIMIT 2
+            `).all(nodeResult.workflowNodeType) as any[];
+
+            if (examples.length > 0) {
+              nodeResult.examples = examples.map((ex: any) => ({
+                configuration: JSON.parse(ex.parameters_json),
+                template: ex.template_name,
+                views: ex.template_views
+              }));
+            }
+          } catch (error: any) {
+            logger.warn(`Failed to fetch examples for ${nodeResult.nodeType}:`, error.message);
+          }
+        }
+      }
+
+      return result;
     }
     
     // Split into words for normal search
@@ -1347,8 +1472,8 @@ export class N8NDocumentationMCPServer {
     
     // Apply relevance ranking
     const rankedNodes = this.rankSearchResults(nodes, query, limit);
-    
-    return {
+
+    const result: any = {
       query,
       results: rankedNodes.map(node => ({
         nodeType: node.node_type,
@@ -1360,6 +1485,36 @@ export class N8NDocumentationMCPServer {
       })),
       totalCount: rankedNodes.length
     };
+
+    // Add examples if requested
+    if (options?.includeExamples) {
+      for (const nodeResult of result.results) {
+        try {
+          const examples = this.db!.prepare(`
+            SELECT
+              parameters_json,
+              template_name,
+              template_views
+            FROM template_node_configs
+            WHERE node_type = ?
+            ORDER BY rank
+            LIMIT 2
+          `).all(nodeResult.workflowNodeType) as any[];
+
+          if (examples.length > 0) {
+            nodeResult.examples = examples.map((ex: any) => ({
+              configuration: JSON.parse(ex.parameters_json),
+              template: ex.template_name,
+              views: ex.template_views
+            }));
+          }
+        } catch (error: any) {
+          logger.warn(`Failed to fetch examples for ${nodeResult.nodeType}:`, error.message);
+        }
+      }
+    }
+
+    return result;
   }
 
   private calculateRelevance(node: NodeRow, query: string): string {
@@ -1548,9 +1703,9 @@ export class N8NDocumentationMCPServer {
   private async getNodeDocumentation(nodeType: string): Promise<any> {
     await this.ensureInitialized();
     if (!this.db) throw new Error('Database not initialized');
-    
+
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.db!.prepare(`
       SELECT node_type, display_name, documentation, description 
       FROM nodes 
@@ -1585,23 +1740,25 @@ export class N8NDocumentationMCPServer {
       throw new Error(`Node ${nodeType} not found`);
     }
     
-    // If no documentation, generate fallback
+    // If no documentation, generate fallback with null safety
     if (!node.documentation) {
       const essentials = await this.getNodeEssentials(nodeType);
-      
+
       return {
         nodeType: node.node_type,
-        displayName: node.display_name,
+        displayName: node.display_name || 'Unknown Node',
         documentation: `
-# ${node.display_name}
+# ${node.display_name || 'Unknown Node'}
 
 ${node.description || 'No description available.'}
 
 ## Common Properties
 
-${essentials.commonProperties.map((p: any) => 
-  `### ${p.displayName}\n${p.description || `Type: ${p.type}`}`
-).join('\n\n')}
+${essentials?.commonProperties?.length > 0 ?
+  essentials.commonProperties.map((p: any) =>
+    `### ${p.displayName || 'Property'}\n${p.description || `Type: ${p.type || 'unknown'}`}`
+  ).join('\n\n') :
+  'No common properties available.'}
 
 ## Note
 Full documentation is being prepared. For now, use get_node_essentials for configuration help.
@@ -1609,10 +1766,10 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
         hasDocumentation: false
       };
     }
-    
+
     return {
       nodeType: node.node_type,
-      displayName: node.display_name,
+      displayName: node.display_name || 'Unknown Node',
       documentation: node.documentation,
       hasDocumentation: true,
     };
@@ -1674,18 +1831,18 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
     };
   }
 
-  private async getNodeEssentials(nodeType: string): Promise<any> {
+  private async getNodeEssentials(nodeType: string, includeExamples?: boolean): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
-    // Check cache first
-    const cacheKey = `essentials:${nodeType}`;
+
+    // Check cache first (cache key includes includeExamples)
+    const cacheKey = `essentials:${nodeType}:${includeExamples ? 'withExamples' : 'basic'}`;
     const cached = this.cache.get(cacheKey);
     if (cached) return cached;
     
     // Get the full node information
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -1721,12 +1878,12 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
     
     const result = {
       nodeType: node.nodeType,
-      workflowNodeType: getWorkflowNodeType(node.package, node.nodeType),
+      workflowNodeType: getWorkflowNodeType(node.package ?? 'n8n-nodes-base', node.nodeType),
       displayName: node.displayName,
       description: node.description,
       category: node.category,
-      version: node.version || '1',
-      isVersioned: node.isVersioned || false,
+      version: node.version ?? '1',
+      isVersioned: node.isVersioned ?? false,
       requiredProperties: essentials.required,
       commonProperties: essentials.common,
       operations: operations.map((op: any) => ({
@@ -1738,28 +1895,74 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
       // Examples removed - use validate_node_operation for working configurations
       metadata: {
         totalProperties: allProperties.length,
-        isAITool: node.isAITool,
-        isTrigger: node.isTrigger,
-        isWebhook: node.isWebhook,
+        isAITool: node.isAITool ?? false,
+        isTrigger: node.isTrigger ?? false,
+        isWebhook: node.isWebhook ?? false,
         hasCredentials: node.credentials ? true : false,
-        package: node.package,
-        developmentStyle: node.developmentStyle || 'programmatic'
+        package: node.package ?? 'n8n-nodes-base',
+        developmentStyle: node.developmentStyle ?? 'programmatic'
       }
     };
-    
+
+    // Add examples from templates if requested
+    if (includeExamples) {
+      try {
+        const fullNodeType = getWorkflowNodeType(node.package ?? 'n8n-nodes-base', node.nodeType);
+        const examples = this.db!.prepare(`
+          SELECT
+            parameters_json,
+            template_name,
+            template_views,
+            complexity,
+            use_cases,
+            has_credentials,
+            has_expressions
+          FROM template_node_configs
+          WHERE node_type = ?
+          ORDER BY rank
+          LIMIT 3
+        `).all(fullNodeType) as any[];
+
+        if (examples.length > 0) {
+          (result as any).examples = examples.map((ex: any) => ({
+            configuration: JSON.parse(ex.parameters_json),
+            source: {
+              template: ex.template_name,
+              views: ex.template_views,
+              complexity: ex.complexity
+            },
+            useCases: ex.use_cases ? JSON.parse(ex.use_cases).slice(0, 2) : [],
+            metadata: {
+              hasCredentials: ex.has_credentials === 1,
+              hasExpressions: ex.has_expressions === 1
+            }
+          }));
+
+          (result as any).examplesCount = examples.length;
+        } else {
+          (result as any).examples = [];
+          (result as any).examplesCount = 0;
+        }
+      } catch (error: any) {
+        logger.warn(`Failed to fetch examples for ${nodeType}:`, error.message);
+        (result as any).examples = [];
+        (result as any).examplesCount = 0;
+      }
+    }
+
     // Cache for 1 hour
     this.cache.set(cacheKey, result, 3600);
-    
+
     return result;
   }
 
   private async searchNodeProperties(nodeType: string, query: string, maxResults: number = 20): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
+
     // Get the node
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -1807,43 +2010,6 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
     };
   }
 
-  private async getNodeForTask(task: string): Promise<any> {
-    const template = TaskTemplates.getTaskTemplate(task);
-    
-    if (!template) {
-      // Try to find similar tasks
-      const similar = TaskTemplates.searchTasks(task);
-      throw new Error(
-        `Unknown task: ${task}. ` +
-        (similar.length > 0 
-          ? `Did you mean: ${similar.slice(0, 3).join(', ')}?`
-          : `Use 'list_tasks' to see available tasks.`)
-      );
-    }
-    
-    return {
-      task: template.task,
-      description: template.description,
-      nodeType: template.nodeType,
-      configuration: template.configuration,
-      userMustProvide: template.userMustProvide,
-      optionalEnhancements: template.optionalEnhancements || [],
-      notes: template.notes || [],
-      example: {
-        node: {
-          type: template.nodeType,
-          parameters: template.configuration
-        },
-        userInputsNeeded: template.userMustProvide.map(p => ({
-          property: p.property,
-          currentValue: this.getPropertyValue(template.configuration, p.property),
-          description: p.description,
-          example: p.example
-        }))
-      }
-    };
-  }
-  
   private getPropertyValue(config: any, path: string): any {
     const parts = path.split('.');
     let value = config;
@@ -1914,17 +2080,17 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
   ): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
+
     // Get node info to access properties
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
-    
+
     if (!node && normalizedType !== nodeType) {
       // Try original if normalization changed it
       node = this.repository.getNode(nodeType);
     }
-    
+
     if (!node) {
       // Fallback to other alternatives for edge cases
       const alternatives = getNodeTypeAlternatives(normalizedType);
@@ -1972,10 +2138,10 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
   private async getPropertyDependencies(nodeType: string, config?: Record<string, any>): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
+
     // Get node info to access properties
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -2026,10 +2192,10 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
   private async getNodeAsToolInfo(nodeType: string): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
+
     // Get node info
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -2249,10 +2415,10 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
   private async validateNodeMinimal(nodeType: string, config: Record<string, any>): Promise<any> {
     await this.ensureInitialized();
     if (!this.repository) throw new Error('Repository not initialized');
-    
+
     // Get node info
     // First try with normalized type
-    const normalizedType = normalizeNodeType(nodeType);
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
     let node = this.repository.getNode(normalizedType);
     
     if (!node && normalizedType !== nodeType) {
@@ -2601,29 +2767,45 @@ Full documentation is being prepared. For now, use get_node_essentials for confi
           expressionsValidated: result.statistics.expressionsValidated,
           errorCount: result.errors.length,
           warningCount: result.warnings.length
-        }
-      };
-      
-      if (result.errors.length > 0) {
-        response.errors = result.errors.map(e => ({
+        },
+        // Always include errors and warnings arrays for consistent API response
+        errors: result.errors.map(e => ({
           node: e.nodeName || 'workflow',
           message: e.message,
           details: e.details
-        }));
-      }
-      
-      if (result.warnings.length > 0) {
-        response.warnings = result.warnings.map(w => ({
+        })),
+        warnings: result.warnings.map(w => ({
           node: w.nodeName || 'workflow',
           message: w.message,
           details: w.details
-        }));
-      }
+        }))
+      };
       
       if (result.suggestions.length > 0) {
         response.suggestions = result.suggestions;
       }
-      
+
+      // Track validation details in telemetry
+      if (!result.valid && result.errors.length > 0) {
+        // Track each validation error for analysis
+        result.errors.forEach(error => {
+          telemetry.trackValidationDetails(
+            error.nodeName || 'workflow',
+            error.type || 'validation_error',
+            {
+              message: error.message,
+              nodeCount: workflow.nodes?.length ?? 0,
+              hasConnections: Object.keys(workflow.connections || {}).length > 0
+            }
+          );
+        });
+      }
+
+      // Track successfully validated workflows in telemetry
+      if (result.valid) {
+        telemetry.trackWorkflowCreation(workflow, true);
+      }
+
       return response;
     } catch (error) {
       logger.error('Error validating workflow:', error);

src/mcp/tool-docs/index.ts

@@ -17,14 +17,13 @@ import {
   validateWorkflowConnectionsDoc,
   validateWorkflowExpressionsDoc
 } from './validation';
-import { 
-  listTasksDoc, 
-  getNodeForTaskDoc, 
-  listNodeTemplatesDoc, 
-  getTemplateDoc, 
+import {
+  listTasksDoc,
+  listNodeTemplatesDoc,
+  getTemplateDoc,
   searchTemplatesDoc,
-  searchTemplatesByMetadataDoc, 
-  getTemplatesForTaskDoc 
+  searchTemplatesByMetadataDoc,
+  getTemplatesForTaskDoc
 } from './templates';
 import { 
   toolsDocumentationDoc,
@@ -43,6 +42,7 @@ import {
   n8nDeleteWorkflowDoc,
   n8nListWorkflowsDoc,
   n8nValidateWorkflowDoc,
+  n8nAutofixWorkflowDoc,
   n8nTriggerWebhookWorkflowDoc,
   n8nGetExecutionDoc,
   n8nListExecutionsDoc,
@@ -80,7 +80,6 @@ export const toolsDocumentation: Record<string, ToolDocumentation> = {
   
   // Template tools
   list_tasks: listTasksDoc,
-  get_node_for_task: getNodeForTaskDoc,
   list_node_templates: listNodeTemplatesDoc,
   get_template: getTemplateDoc,
   search_templates: searchTemplatesDoc,
@@ -98,6 +97,7 @@ export const toolsDocumentation: Record<string, ToolDocumentation> = {
   n8n_delete_workflow: n8nDeleteWorkflowDoc,
   n8n_list_workflows: n8nListWorkflowsDoc,
   n8n_validate_workflow: n8nValidateWorkflowDoc,
+  n8n_autofix_workflow: n8nAutofixWorkflowDoc,
   n8n_trigger_webhook_workflow: n8nTriggerWebhookWorkflowDoc,
   n8n_get_execution: n8nGetExecutionDoc,
   n8n_list_executions: n8nListExecutionsDoc,

src/mcp/tool-docs/templates/get-node-for-task.ts

@@ -1,48 +0,0 @@
-import { ToolDocumentation } from '../types';
-
-export const getNodeForTaskDoc: ToolDocumentation = {
-  name: 'get_node_for_task',
-  category: 'templates',
-  essentials: {
-    description: 'Get pre-configured node for tasks: post_json_request, receive_webhook, query_database, send_slack_message, etc. Use list_tasks for all.',
-    keyParameters: ['task'],
-    example: 'get_node_for_task({task: "post_json_request"})',
-    performance: 'Instant',
-    tips: [
-      'Returns ready-to-use configuration',
-      'See list_tasks for available tasks',
-      'Includes credentials structure'
-    ]
-  },
-  full: {
-    description: 'Returns pre-configured node settings for common automation tasks. Each configuration includes the correct node type, essential parameters, and credential requirements. Perfect for quickly setting up standard automations.',
-    parameters: {
-      task: { type: 'string', required: true, description: 'Task name from list_tasks (e.g., "post_json_request", "send_email")' }
-    },
-    returns: 'Complete node configuration with type, displayName, parameters, credentials structure',
-    examples: [
-      'get_node_for_task({task: "post_json_request"}) - HTTP POST setup',
-      'get_node_for_task({task: "receive_webhook"}) - Webhook receiver',
-      'get_node_for_task({task: "send_slack_message"}) - Slack config'
-    ],
-    useCases: [
-      'Quick node configuration',
-      'Learning proper node setup',
-      'Standard automation patterns',
-      'Credential structure reference'
-    ],
-    performance: 'Instant - Pre-configured templates',
-    bestPractices: [
-      'Use list_tasks to discover options',
-      'Customize returned config as needed',
-      'Check credential requirements',
-      'Validate with validate_node_operation'
-    ],
-    pitfalls: [
-      'Templates may need customization',
-      'Credentials must be configured separately',
-      'Not all tasks available for all nodes'
-    ],
-    relatedTools: ['list_tasks', 'validate_node_operation', 'get_node_essentials']
-  }
-};

src/mcp/tool-docs/templates/index.ts

@@ -1,4 +1,3 @@
-export { getNodeForTaskDoc } from './get-node-for-task';
 export { listTasksDoc } from './list-tasks';
 export { listNodeTemplatesDoc } from './list-node-templates';
 export { getTemplateDoc } from './get-template';

src/mcp/tool-docs/types.ts

@@ -10,9 +10,9 @@ export interface ToolDocumentation {
   };
   full: {
     description: string;
-    parameters: Record<string, { 
-      type: string; 
-      description: string; 
+    parameters: Record<string, {
+      type: string;
+      description: string;
       required?: boolean;
       default?: any;
       examples?: string[];
@@ -22,8 +22,10 @@ export interface ToolDocumentation {
     examples: string[];
     useCases: string[];
     performance: string;
+    errorHandling?: string; // Optional: Documentation on error handling and debugging
     bestPractices: string[];
     pitfalls: string[];
+    modeComparison?: string; // Optional: Comparison of different modes for tools with multiple modes
     relatedTools: string[];
   };
 }

src/mcp/tool-docs/validation/validate-workflow.ts

@@ -76,6 +76,6 @@ export const validateWorkflowDoc: ToolDocumentation = {
       'Validation cannot catch all runtime errors (e.g., API failures)',
       'Profile setting only affects node validation, not connection/expression checks'
     ],
-    relatedTools: ['validate_workflow_connections', 'validate_workflow_expressions', 'validate_node_operation', 'n8n_create_workflow', 'n8n_update_partial_workflow']
+    relatedTools: ['validate_workflow_connections', 'validate_workflow_expressions', 'validate_node_operation', 'n8n_create_workflow', 'n8n_update_partial_workflow', 'n8n_autofix_workflow']
   }
 };

src/mcp/tool-docs/workflow_management/index.ts

@@ -8,6 +8,7 @@ export { n8nUpdatePartialWorkflowDoc } from './n8n-update-partial-workflow';
 export { n8nDeleteWorkflowDoc } from './n8n-delete-workflow';
 export { n8nListWorkflowsDoc } from './n8n-list-workflows';
 export { n8nValidateWorkflowDoc } from './n8n-validate-workflow';
+export { n8nAutofixWorkflowDoc } from './n8n-autofix-workflow';
 export { n8nTriggerWebhookWorkflowDoc } from './n8n-trigger-webhook-workflow';
 export { n8nGetExecutionDoc } from './n8n-get-execution';
 export { n8nListExecutionsDoc } from './n8n-list-executions';

src/mcp/tool-docs/workflow_management/n8n-autofix-workflow.ts

@@ -0,0 +1,125 @@
+import { ToolDocumentation } from '../types';
+
+export const n8nAutofixWorkflowDoc: ToolDocumentation = {
+  name: 'n8n_autofix_workflow',
+  category: 'workflow_management',
+  essentials: {
+    description: 'Automatically fix common workflow validation errors - expression formats, typeVersions, error outputs, webhook paths',
+    keyParameters: ['id', 'applyFixes'],
+    example: 'n8n_autofix_workflow({id: "wf_abc123", applyFixes: false})',
+    performance: 'Network-dependent (200-1000ms) - fetches, validates, and optionally updates workflow',
+    tips: [
+      'Use applyFixes: false to preview changes before applying',
+      'Set confidenceThreshold to control fix aggressiveness (high/medium/low)',
+      'Supports fixing expression formats, typeVersion issues, error outputs, node type corrections, and webhook paths',
+      'High-confidence fixes (≥90%) are safe for auto-application'
+    ]
+  },
+  full: {
+    description: `Automatically detects and fixes common workflow validation errors in n8n workflows. This tool:
+
+- Fetches the workflow from your n8n instance
+- Runs comprehensive validation to detect issues
+- Generates targeted fixes for common problems
+- Optionally applies the fixes back to the workflow
+
+The auto-fixer can resolve:
+1. **Expression Format Issues**: Missing '=' prefix in n8n expressions (e.g., {{ $json.field }} → ={{ $json.field }})
+2. **TypeVersion Corrections**: Downgrades nodes with unsupported typeVersions to maximum supported
+3. **Error Output Configuration**: Removes conflicting onError settings when error connections are missing
+4. **Node Type Corrections**: Intelligently fixes unknown node types using similarity matching:
+   - Handles deprecated package prefixes (n8n-nodes-base. → nodes-base.)
+   - Corrects capitalization mistakes (HttpRequest → httpRequest)
+   - Suggests correct packages (nodes-base.openai → nodes-langchain.openAi)
+   - Uses multi-factor scoring: name similarity, category match, package match, pattern match
+   - Only auto-fixes suggestions with ≥90% confidence
+   - Leverages NodeSimilarityService with 5-minute caching for performance
+5. **Webhook Path Generation**: Automatically generates UUIDs for webhook nodes missing path configuration:
+   - Generates a unique UUID for webhook path
+   - Sets both 'path' parameter and 'webhookId' field to the same UUID
+   - Ensures webhook nodes become functional with valid endpoints
+   - High confidence fix as UUID generation is deterministic
+
+The tool uses a confidence-based system to ensure safe fixes:
+- **High (≥90%)**: Safe to auto-apply (exact matches, known patterns)
+- **Medium (70-89%)**: Generally safe but review recommended
+- **Low (<70%)**: Manual review strongly recommended
+
+Requires N8N_API_URL and N8N_API_KEY environment variables to be configured.`,
+    parameters: {
+      id: {
+        type: 'string',
+        required: true,
+        description: 'The workflow ID to fix in your n8n instance'
+      },
+      applyFixes: {
+        type: 'boolean',
+        required: false,
+        description: 'Whether to apply fixes to the workflow (default: false - preview mode). When false, returns proposed fixes without modifying the workflow.'
+      },
+      fixTypes: {
+        type: 'array',
+        required: false,
+        description: 'Types of fixes to apply. Options: ["expression-format", "typeversion-correction", "error-output-config", "node-type-correction", "webhook-missing-path"]. Default: all types.'
+      },
+      confidenceThreshold: {
+        type: 'string',
+        required: false,
+        description: 'Minimum confidence level for fixes: "high" (≥90%), "medium" (≥70%), "low" (any). Default: "medium".'
+      },
+      maxFixes: {
+        type: 'number',
+        required: false,
+        description: 'Maximum number of fixes to apply (default: 50). Useful for limiting scope of changes.'
+      }
+    },
+    returns: `AutoFixResult object containing:
+- operations: Array of diff operations that will be/were applied
+- fixes: Detailed list of individual fixes with before/after values
+- summary: Human-readable summary of fixes
+- stats: Statistics by fix type and confidence level
+- applied: Boolean indicating if fixes were applied (when applyFixes: true)`,
+    examples: [
+      'n8n_autofix_workflow({id: "wf_abc123"}) - Preview all possible fixes',
+      'n8n_autofix_workflow({id: "wf_abc123", applyFixes: true}) - Apply all medium+ confidence fixes',
+      'n8n_autofix_workflow({id: "wf_abc123", applyFixes: true, confidenceThreshold: "high"}) - Only apply high-confidence fixes',
+      'n8n_autofix_workflow({id: "wf_abc123", fixTypes: ["expression-format"]}) - Only fix expression format issues',
+      'n8n_autofix_workflow({id: "wf_abc123", fixTypes: ["webhook-missing-path"]}) - Only fix webhook path issues',
+      'n8n_autofix_workflow({id: "wf_abc123", applyFixes: true, maxFixes: 10}) - Apply up to 10 fixes'
+    ],
+    useCases: [
+      'Fixing workflows imported from older n8n versions',
+      'Correcting expression syntax after manual edits',
+      'Resolving typeVersion conflicts after n8n upgrades',
+      'Cleaning up workflows before production deployment',
+      'Batch fixing common issues across multiple workflows',
+      'Migrating workflows between n8n instances with different versions',
+      'Repairing webhook nodes that lost their path configuration'
+    ],
+    performance: 'Depends on workflow size and number of issues. Preview mode: 200-500ms. Apply mode: 500-1000ms for medium workflows. Node similarity matching is cached for 5 minutes for improved performance on repeated validations.',
+    bestPractices: [
+      'Always preview fixes first (applyFixes: false) before applying',
+      'Start with high confidence threshold for production workflows',
+      'Review the fix summary to understand what changed',
+      'Test workflows after auto-fixing to ensure expected behavior',
+      'Use fixTypes parameter to target specific issue categories',
+      'Keep maxFixes reasonable to avoid too many changes at once'
+    ],
+    pitfalls: [
+      'Some fixes may change workflow behavior - always test after fixing',
+      'Low confidence fixes might not be the intended solution',
+      'Expression format fixes assume standard n8n syntax requirements',
+      'Node type corrections only work for known node types in the database',
+      'Cannot fix structural issues like missing nodes or invalid connections',
+      'TypeVersion downgrades might remove node features added in newer versions',
+      'Generated webhook paths are new UUIDs - existing webhook URLs will change'
+    ],
+    relatedTools: [
+      'n8n_validate_workflow',
+      'validate_workflow',
+      'n8n_update_partial_workflow',
+      'validate_workflow_expressions',
+      'validate_node_operation'
+    ]
+  }
+};

src/mcp/tool-docs/workflow_management/n8n-get-execution.ts

@@ -4,59 +4,280 @@ export const n8nGetExecutionDoc: ToolDocumentation = {
   name: 'n8n_get_execution',
   category: 'workflow_management',
   essentials: {
-    description: 'Get details of a specific execution by ID, including status, timing, and error information.',
-    keyParameters: ['id', 'includeData'],
-    example: 'n8n_get_execution({id: "12345"})',
-    performance: 'Fast lookup, data inclusion may increase response size significantly',
+    description: 'Get execution details with smart filtering to avoid token limits. Use preview mode first to assess data size, then fetch appropriately.',
+    keyParameters: ['id', 'mode', 'itemsLimit', 'nodeNames'],
+    example: `
+// RECOMMENDED WORKFLOW:
+// 1. Preview first
+n8n_get_execution({id: "12345", mode: "preview"})
+// Returns: structure, counts, size estimate, recommendation
+
+// 2. Based on recommendation, fetch data:
+n8n_get_execution({id: "12345", mode: "summary"}) // 2 items per node
+n8n_get_execution({id: "12345", mode: "filtered", itemsLimit: 5}) // 5 items
+n8n_get_execution({id: "12345", nodeNames: ["HTTP Request"]}) // Specific node
+`,
+    performance: 'Preview: <50ms, Summary: <200ms, Full: depends on data size',
     tips: [
-      'Use includeData:true to see full execution data and node outputs',
-      'Execution IDs come from list_executions or webhook responses',
-      'Check status field for success/error/waiting states'
+      'ALWAYS use preview mode first for large datasets',
+      'Preview shows structure + counts without consuming tokens for data',
+      'Summary mode (2 items per node) is safe default',
+      'Use nodeNames to focus on specific nodes only',
+      'itemsLimit: 0 = structure only, -1 = unlimited',
+      'Check recommendation.suggestedMode from preview'
     ]
   },
   full: {
-    description: `Retrieves detailed information about a specific workflow execution. This tool is essential for monitoring workflow runs, debugging failures, and accessing execution results. Returns execution metadata by default, with optional full data inclusion for complete visibility into node inputs/outputs.`,
+    description: `Retrieves and intelligently filters execution data to enable inspection without exceeding token limits. This tool provides multiple modes for different use cases, from quick previews to complete data retrieval.
+
+**The Problem**: Workflows processing large datasets (50+ database records) generate execution data that exceeds token/response limits, making traditional full-data fetching impossible.
+
+**The Solution**: Four retrieval modes with smart filtering:
+1. **Preview**: Structure + counts only (no actual data)
+2. **Summary**: 2 sample items per node (safe default)
+3. **Filtered**: Custom limits and node selection
+4. **Full**: Complete data (use with caution)
+
+**Recommended Workflow**:
+1. Start with preview mode to assess size
+2. Use recommendation to choose appropriate mode
+3. Fetch filtered data as needed`,
+
     parameters: {
       id: {
         type: 'string',
         required: true,
         description: 'The execution ID to retrieve. Obtained from list_executions or webhook trigger responses'
       },
+      mode: {
+        type: 'string',
+        required: false,
+        description: `Retrieval mode (default: auto-detect from other params):
+- 'preview': Structure, counts, size estimates - NO actual data (fastest)
+- 'summary': Metadata + 2 sample items per node (safe default)
+- 'filtered': Custom filtering with itemsLimit/nodeNames
+- 'full': Complete execution data (use with caution)`
+      },
+      nodeNames: {
+        type: 'array',
+        required: false,
+        description: 'Filter to specific nodes by name. Example: ["HTTP Request", "Filter"]. Useful when you only need to inspect specific nodes.'
+      },
+      itemsLimit: {
+        type: 'number',
+        required: false,
+        description: `Items to return per node (default: 2):
+- 0: Structure only (see data shape without values)
+- 1-N: Return N items per node
+- -1: Unlimited (return all items)
+
+Note: Structure-only mode (0) shows JSON schema without actual values.`
+      },
+      includeInputData: {
+        type: 'boolean',
+        required: false,
+        description: 'Include input data in addition to output data (default: false). Useful for debugging data transformations.'
+      },
       includeData: {
         type: 'boolean',
         required: false,
-        description: 'Include full execution data with node inputs/outputs (default: false). Significantly increases response size'
+        description: 'DEPRECATED: Legacy parameter. Use mode instead. If true, maps to mode="summary" for backward compatibility.'
       }
     },
-    returns: `Execution object containing status, timing, error details, and optionally full execution data with all node inputs/outputs.`,
-    examples: [
-      'n8n_get_execution({id: "12345"}) - Get execution summary only',
-      'n8n_get_execution({id: "12345", includeData: true}) - Get full execution with all data',
-      'n8n_get_execution({id: "67890"}) - Check status of a running execution',
-      'n8n_get_execution({id: "failed-123", includeData: true}) - Debug failed execution with error details'
-    ],
-    useCases: [
-      'Monitor status of triggered workflow executions',
-      'Debug failed workflows by examining error messages',
-      'Access execution results and node output data',
-      'Track execution duration and performance metrics',
-      'Verify successful completion of critical workflows'
-    ],
-    performance: `Metadata retrieval is fast (< 100ms). Including full data (includeData: true) can significantly increase response time and size, especially for workflows processing large datasets. Use data inclusion judiciously.`,
-    bestPractices: [
-      'Start with includeData:false to check status first',
-      'Only include data when you need to see node outputs',
-      'Store execution IDs from trigger responses for tracking',
-      'Check status field to determine if execution completed',
-      'Use error field to diagnose execution failures'
-    ],
-    pitfalls: [
-      'Large executions with includeData:true can timeout or exceed limits',
-      'Execution data is retained based on n8n settings - old executions may be purged',
-      'Waiting status indicates execution is still running',
-      'Error executions may have partial data from successful nodes',
-      'Execution IDs are unique per n8n instance'
-    ],
-    relatedTools: ['n8n_list_executions', 'n8n_trigger_webhook_workflow', 'n8n_delete_execution', 'n8n_get_workflow']
+
+    returns: `**Preview Mode Response**:
+{
+  mode: 'preview',
+  preview: {
+    totalNodes: number,
+    executedNodes: number,
+    estimatedSizeKB: number,
+    nodes: {
+      [nodeName]: {
+        status: 'success' | 'error',
+        itemCounts: { input: number, output: number },
+        dataStructure: {...}, // JSON schema
+        estimatedSizeKB: number
+      }
+    }
+  },
+  recommendation: {
+    canFetchFull: boolean,
+    suggestedMode: 'preview'|'summary'|'filtered'|'full',
+    suggestedItemsLimit?: number,
+    reason: string
   }
-};
+}
+
+**Summary/Filtered/Full Mode Response**:
+{
+  mode: 'summary' | 'filtered' | 'full',
+  summary: {
+    totalNodes: number,
+    executedNodes: number,
+    totalItems: number,
+    hasMoreData: boolean  // true if truncated
+  },
+  nodes: {
+    [nodeName]: {
+      executionTime: number,
+      itemsInput: number,
+      itemsOutput: number,
+      status: 'success' | 'error',
+      error?: string,
+      data: {
+        output: [...],  // Actual data items
+        metadata: {
+          totalItems: number,
+          itemsShown: number,
+          truncated: boolean
+        }
+      }
+    }
+  }
+}`,
+
+    examples: [
+      `// Example 1: Preview workflow (RECOMMENDED FIRST STEP)
+n8n_get_execution({id: "exec_123", mode: "preview"})
+// Returns structure, counts, size, recommendation
+// Use this to decide how to fetch data`,
+
+      `// Example 2: Follow recommendation
+const preview = n8n_get_execution({id: "exec_123", mode: "preview"});
+if (preview.recommendation.canFetchFull) {
+  n8n_get_execution({id: "exec_123", mode: "full"});
+} else {
+  n8n_get_execution({
+    id: "exec_123",
+    mode: "filtered",
+    itemsLimit: preview.recommendation.suggestedItemsLimit
+  });
+}`,
+
+      `// Example 3: Summary mode (safe default for unknown datasets)
+n8n_get_execution({id: "exec_123", mode: "summary"})
+// Gets 2 items per node - safe for most cases`,
+
+      `// Example 4: Filter to specific node
+n8n_get_execution({
+  id: "exec_123",
+  mode: "filtered",
+  nodeNames: ["HTTP Request"],
+  itemsLimit: 5
+})
+// Gets only HTTP Request node, 5 items`,
+
+      `// Example 5: Structure only (see data shape)
+n8n_get_execution({
+  id: "exec_123",
+  mode: "filtered",
+  itemsLimit: 0
+})
+// Returns JSON schema without actual values`,
+
+      `// Example 6: Debug with input data
+n8n_get_execution({
+  id: "exec_123",
+  mode: "filtered",
+  nodeNames: ["Transform"],
+  itemsLimit: 2,
+  includeInputData: true
+})
+// See both input and output for debugging`,
+
+      `// Example 7: Backward compatibility (legacy)
+n8n_get_execution({id: "exec_123"}) // Minimal data
+n8n_get_execution({id: "exec_123", includeData: true}) // Maps to summary mode`
+    ],
+
+    useCases: [
+      'Monitor status of triggered workflows',
+      'Debug failed workflows by examining error messages and partial data',
+      'Inspect large datasets without exceeding token limits',
+      'Validate data transformations between nodes',
+      'Understand execution flow and timing',
+      'Track workflow performance metrics',
+      'Verify successful completion before proceeding',
+      'Extract specific data from execution results'
+    ],
+
+    performance: `**Response Times** (approximate):
+- Preview mode: <50ms (no data, just structure)
+- Summary mode: <200ms (2 items per node)
+- Filtered mode: 50-500ms (depends on filters)
+- Full mode: 200ms-5s (depends on data size)
+
+**Token Consumption**:
+- Preview: ~500 tokens (no data values)
+- Summary (2 items): ~2-5K tokens
+- Filtered (5 items): ~5-15K tokens
+- Full (50+ items): 50K+ tokens (may exceed limits)
+
+**Optimization Tips**:
+- Use preview for all large datasets
+- Use nodeNames to focus on relevant nodes only
+- Start with small itemsLimit and increase if needed
+- Use itemsLimit: 0 to see structure without data`,
+
+    bestPractices: [
+      'ALWAYS use preview mode first for unknown datasets',
+      'Trust the recommendation.suggestedMode from preview',
+      'Use nodeNames to filter to relevant nodes only',
+      'Start with summary mode if preview indicates moderate size',
+      'Use itemsLimit: 0 to understand data structure',
+      'Check hasMoreData to know if results are truncated',
+      'Store execution IDs from triggers for later inspection',
+      'Use mode="filtered" with custom limits for large datasets',
+      'Include input data only when debugging transformations',
+      'Monitor summary.totalItems to understand dataset size'
+    ],
+
+    pitfalls: [
+      'DON\'T fetch full mode without previewing first - may timeout',
+      'DON\'T assume all data fits - always check hasMoreData',
+      'DON\'T ignore the recommendation from preview mode',
+      'Execution data is retained based on n8n settings - old executions may be purged',
+      'Binary data (files, images) is not fully included - only metadata',
+      'Status "waiting" indicates execution is still running',
+      'Error executions may have partial data from successful nodes',
+      'Very large individual items (>1MB) may be truncated',
+      'Preview mode estimates may be off by 10-20% for complex structures',
+      'Node names are case-sensitive in nodeNames filter'
+    ],
+
+    modeComparison: `**When to use each mode**:
+
+**Preview**:
+- ALWAYS use first for unknown datasets
+- When you need to know if data is safe to fetch
+- To see data structure without consuming tokens
+- To get size estimates and recommendations
+
+**Summary** (default):
+- Safe default for most cases
+- When you need representative samples
+- When preview recommends it
+- For quick data inspection
+
+**Filtered**:
+- When you need specific nodes only
+- When you need more than 2 items but not all
+- When preview recommends it with itemsLimit
+- For targeted data extraction
+
+**Full**:
+- ONLY when preview says canFetchFull: true
+- For small executions (< 20 items total)
+- When you genuinely need all data
+- When you're certain data fits in token limit`,
+
+    relatedTools: [
+      'n8n_list_executions - Find execution IDs',
+      'n8n_trigger_webhook_workflow - Trigger and get execution ID',
+      'n8n_delete_execution - Clean up old executions',
+      'n8n_get_workflow - Get workflow structure',
+      'validate_workflow - Validate before executing'
+    ]
+  }
+};

src/mcp/tool-docs/workflow_management/n8n-trigger-webhook-workflow.ts

@@ -59,19 +59,59 @@ export const n8nTriggerWebhookWorkflowDoc: ToolDocumentation = {
       'Implement event-driven architectures with n8n'
     ],
     performance: `Performance varies based on workflow complexity and waitForResponse setting. Synchronous calls (waitForResponse: true) block until workflow completes. For long-running workflows, use async mode (waitForResponse: false) and monitor execution separately.`,
+    errorHandling: `**Enhanced Error Messages with Execution Guidance**
+
+When a webhook trigger fails, the error response now includes specific guidance to help debug the issue:
+
+**Error with Execution ID** (workflow started but failed):
+- Format: "Workflow {workflowId} execution {executionId} failed. Use n8n_get_execution({id: '{executionId}', mode: 'preview'}) to investigate the error."
+- Response includes: executionId and workflowId fields for direct access
+- Recommended action: Use n8n_get_execution with mode='preview' for fast, efficient error inspection
+
+**Error without Execution ID** (workflow didn't start):
+- Format: "Workflow failed to execute. Use n8n_list_executions to find recent executions, then n8n_get_execution with mode='preview' to investigate."
+- Recommended action: Check recent executions with n8n_list_executions
+
+**Why mode='preview'?**
+- Fast: <50ms response time
+- Efficient: ~500 tokens (vs 50K+ for full mode)
+- Safe: No timeout or token limit risks
+- Informative: Shows structure, counts, and error details
+- Provides recommendations for fetching more data if needed
+
+**Example Error Responses**:
+\`\`\`json
+{
+  "success": false,
+  "error": "Workflow wf_123 execution exec_456 failed. Use n8n_get_execution({id: 'exec_456', mode: 'preview'}) to investigate the error.",
+  "executionId": "exec_456",
+  "workflowId": "wf_123",
+  "code": "SERVER_ERROR"
+}
+\`\`\`
+
+**Investigation Workflow**:
+1. Trigger returns error with execution ID
+2. Call n8n_get_execution({id: executionId, mode: 'preview'}) to see structure and error
+3. Based on preview recommendation, fetch more data if needed
+4. Fix issues in workflow and retry`,
     bestPractices: [
       'Always verify workflow is active before attempting webhook triggers',
       'Match HTTP method exactly with webhook node configuration',
       'Use async mode (waitForResponse: false) for long-running workflows',
       'Include authentication headers when webhook requires them',
-      'Test webhook URL manually first to ensure it works'
+      'Test webhook URL manually first to ensure it works',
+      'When errors occur, use n8n_get_execution with mode="preview" first for efficient debugging',
+      'Store execution IDs from error responses for later investigation'
     ],
     pitfalls: [
       'Workflow must be ACTIVE - inactive workflows cannot be triggered',
       'HTTP method mismatch returns 404 even if URL is correct',
       'Webhook node must be the trigger node in the workflow',
       'Timeout errors occur with long workflows in sync mode',
-      'Data format must match webhook node expectations'
+      'Data format must match webhook node expectations',
+      'Error messages always include n8n_get_execution guidance - follow the suggested steps for efficient debugging',
+      'Execution IDs in error responses are crucial for debugging - always check for and use them'
     ],
     relatedTools: ['n8n_get_execution', 'n8n_list_executions', 'n8n_get_workflow', 'n8n_create_workflow']
   }

src/mcp/tool-docs/workflow_management/n8n-update-partial-workflow.ts

@@ -4,18 +4,19 @@ export const n8nUpdatePartialWorkflowDoc: ToolDocumentation = {
   name: 'n8n_update_partial_workflow',
   category: 'workflow_management',
   essentials: {
-    description: 'Update workflow incrementally with diff operations. Max 5 ops. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, updateSettings, updateName, add/removeTag.',
-    keyParameters: ['id', 'operations'],
-    example: 'n8n_update_partial_workflow({id: "wf_123", operations: [{type: "updateNode", ...}]})',
+    description: 'Update workflow incrementally with diff operations. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, cleanStaleConnections, replaceConnections, updateSettings, updateName, add/removeTag.',
+    keyParameters: ['id', 'operations', 'continueOnError'],
+    example: 'n8n_update_partial_workflow({id: "wf_123", operations: [{type: "cleanStaleConnections"}]})',
     performance: 'Fast (50-200ms)',
     tips: [
-      'Use for targeted changes',
-      'Supports up to 5 operations',
+      'Use cleanStaleConnections to auto-remove broken connections',
+      'Set ignoreErrors:true on removeConnection for cleanup',
+      'Use continueOnError mode for best-effort bulk operations',
       'Validate with validateOnly first'
     ]
   },
   full: {
-    description: `Updates workflows using surgical diff operations instead of full replacement. Supports 13 operation types for precise modifications. Operations are validated and applied atomically - all succeed or none are applied. Maximum 5 operations per call for safety.
+    description: `Updates workflows using surgical diff operations instead of full replacement. Supports 15 operation types for precise modifications. Operations are validated and applied atomically by default - all succeed or none are applied. v2.14.4 adds cleanup operations and best-effort mode for workflow recovery scenarios.
 
 ## Available Operations:
 
@@ -27,53 +28,81 @@ export const n8nUpdatePartialWorkflowDoc: ToolDocumentation = {
 - **enableNode**: Enable a disabled node
 - **disableNode**: Disable an active node
 
-### Connection Operations (3 types):
+### Connection Operations (5 types):
 - **addConnection**: Connect nodes (source→target)
-- **removeConnection**: Remove connection between nodes
+- **removeConnection**: Remove connection between nodes (supports ignoreErrors flag)
 - **updateConnection**: Modify connection properties
+- **cleanStaleConnections**: Auto-remove all connections referencing non-existent nodes (NEW in v2.14.4)
+- **replaceConnections**: Replace entire connections object (NEW in v2.14.4)
 
 ### Metadata Operations (4 types):
 - **updateSettings**: Modify workflow settings
 - **updateName**: Rename the workflow
 - **addTag**: Add a workflow tag
-- **removeTag**: Remove a workflow tag`,
+- **removeTag**: Remove a workflow tag
+
+## New in v2.14.4: Cleanup & Recovery Features
+
+### Automatic Cleanup
+The **cleanStaleConnections** operation automatically removes broken connection references after node renames/deletions. Essential for workflow recovery.
+
+### Best-Effort Mode
+Set **continueOnError: true** to apply valid operations even if some fail. Returns detailed results showing which operations succeeded/failed. Perfect for bulk cleanup operations.
+
+### Graceful Error Handling
+Add **ignoreErrors: true** to removeConnection operations to prevent failures when connections don't exist.`,
     parameters: {
       id: { type: 'string', required: true, description: 'Workflow ID to update' },
-      operations: { 
-        type: 'array', 
-        required: true, 
-        description: 'Array of diff operations. Each must have "type" field and operation-specific properties. Max 5 operations. Nodes can be referenced by ID or name.' 
+      operations: {
+        type: 'array',
+        required: true,
+        description: 'Array of diff operations. Each must have "type" field and operation-specific properties. Nodes can be referenced by ID or name.'
       },
-      validateOnly: { type: 'boolean', description: 'If true, only validate operations without applying them' }
+      validateOnly: { type: 'boolean', description: 'If true, only validate operations without applying them' },
+      continueOnError: { type: 'boolean', description: 'If true, apply valid operations even if some fail (best-effort mode). Returns applied and failed operation indices. Default: false (atomic)' }
     },
     returns: 'Updated workflow object or validation results if validateOnly=true',
     examples: [
-      '// Update node parameter\nn8n_update_partial_workflow({id: "abc", operations: [{type: "updateNode", nodeName: "HTTP Request", updates: {"parameters.url": "https://api.example.com"}}]})',
-      '// Add connection between nodes\nn8n_update_partial_workflow({id: "xyz", operations: [{type: "addConnection", source: "Webhook", target: "Slack", sourceOutput: "main", targetInput: "main"}]})',
-      '// Multiple operations in one call\nn8n_update_partial_workflow({id: "123", operations: [\n  {type: "addNode", node: {name: "Transform", type: "n8n-nodes-base.code", position: [400, 300]}},\n  {type: "addConnection", source: "Webhook", target: "Transform"},\n  {type: "updateSettings", settings: {timezone: "America/New_York"}}\n]})',
-      '// Validate before applying\nn8n_update_partial_workflow({id: "456", operations: [{type: "removeNode", nodeName: "Old Process"}], validateOnly: true})'
+      '// Add a basic node (minimal configuration)\nn8n_update_partial_workflow({id: "abc", operations: [{type: "addNode", node: {name: "Process Data", type: "n8n-nodes-base.set", position: [400, 300], parameters: {}}}]})',
+      '// Add node with full configuration\nn8n_update_partial_workflow({id: "def", operations: [{type: "addNode", node: {name: "Send Slack Alert", type: "n8n-nodes-base.slack", position: [600, 300], typeVersion: 2, parameters: {resource: "message", operation: "post", channel: "#alerts", text: "Success!"}}}]})',
+      '// Add node AND connect it (common pattern)\nn8n_update_partial_workflow({id: "ghi", operations: [\n  {type: "addNode", node: {name: "HTTP Request", type: "n8n-nodes-base.httpRequest", position: [400, 300], parameters: {url: "https://api.example.com", method: "GET"}}},\n  {type: "addConnection", source: "Webhook", target: "HTTP Request"}\n]})',
+      '// Add multiple nodes in batch\nn8n_update_partial_workflow({id: "jkl", operations: [\n  {type: "addNode", node: {name: "Filter", type: "n8n-nodes-base.filter", position: [400, 300], parameters: {}}},\n  {type: "addNode", node: {name: "Transform", type: "n8n-nodes-base.set", position: [600, 300], parameters: {}}},\n  {type: "addConnection", source: "Filter", target: "Transform"}\n]})',
+      '// Clean up stale connections after node renames/deletions\nn8n_update_partial_workflow({id: "mno", operations: [{type: "cleanStaleConnections"}]})',
+      '// Remove connection gracefully (no error if it doesn\'t exist)\nn8n_update_partial_workflow({id: "pqr", operations: [{type: "removeConnection", source: "Old Node", target: "Target", ignoreErrors: true}]})',
+      '// Best-effort mode: apply what works, report what fails\nn8n_update_partial_workflow({id: "stu", operations: [\n  {type: "updateName", name: "Fixed Workflow"},\n  {type: "removeConnection", source: "Broken", target: "Node"},\n  {type: "cleanStaleConnections"}\n], continueOnError: true})',
+      '// Replace entire connections object\nn8n_update_partial_workflow({id: "vwx", operations: [{type: "replaceConnections", connections: {"Webhook": {"main": [[{node: "Slack", type: "main", index: 0}]]}}}]})',
+      '// Update node parameter (classic atomic mode)\nn8n_update_partial_workflow({id: "yza", operations: [{type: "updateNode", nodeName: "HTTP Request", updates: {"parameters.url": "https://api.example.com"}}]})',
+      '// Validate before applying\nn8n_update_partial_workflow({id: "bcd", operations: [{type: "removeNode", nodeName: "Old Process"}], validateOnly: true})'
     ],
     useCases: [
+      'Clean up broken workflows after node renames/deletions',
+      'Bulk connection cleanup with best-effort mode',
       'Update single node parameters',
-      'Add/remove connections',
+      'Replace all connections at once',
+      'Graceful cleanup operations that don\'t fail',
       'Enable/disable nodes',
       'Rename workflows or nodes',
       'Manage tags efficiently'
     ],
     performance: 'Very fast - typically 50-200ms. Much faster than full updates as only changes are processed.',
     bestPractices: [
-      'Use validateOnly to test operations',
+      'Use cleanStaleConnections after renaming/removing nodes',
+      'Use continueOnError for bulk cleanup operations',
+      'Set ignoreErrors:true on removeConnection for graceful cleanup',
+      'Use validateOnly to test operations before applying',
       'Group related changes in one call',
-      'Keep operations under 5 for clarity',
-      'Check operation order for dependencies'
+      'Check operation order for dependencies',
+      'Use atomic mode (default) for critical updates'
     ],
     pitfalls: [
       '**REQUIRES N8N_API_URL and N8N_API_KEY environment variables** - will not work without n8n API access',
-      'Maximum 5 operations per call - split larger updates',
-      'Operations validated together - all must be valid',
+      'Atomic mode (default): all operations must succeed or none are applied',
+      'continueOnError breaks atomic guarantees - use with caution',
       'Order matters for dependent operations (e.g., must add node before connecting to it)',
       'Node references accept ID or name, but name must be unique',
-      'Use "updates" property for updateNode operations: {type: "updateNode", updates: {...}}'
+      'Use "updates" property for updateNode operations: {type: "updateNode", updates: {...}}',
+      'cleanStaleConnections removes ALL broken connections - cannot be selective',
+      'replaceConnections overwrites entire connections object - all previous connections lost'
     ],
     relatedTools: ['n8n_update_full_workflow', 'n8n_get_workflow', 'validate_workflow', 'tools_documentation']
   }

src/mcp/tool-docs/workflow_management/n8n-validate-workflow.ts

@@ -66,6 +66,6 @@ Requires N8N_API_URL and N8N_API_KEY environment variables to be configured.`,
       'Profile affects validation time - strict is slower but more thorough',
       'Expression validation may flag working but non-standard syntax'
     ],
-    relatedTools: ['validate_workflow', 'n8n_get_workflow', 'validate_workflow_expressions', 'n8n_health_check']
+    relatedTools: ['validate_workflow', 'n8n_get_workflow', 'validate_workflow_expressions', 'n8n_health_check', 'n8n_autofix_workflow']
   }
 };

src/mcp/tools-n8n-manager.ts

@@ -160,7 +160,7 @@ export const n8nManagementTools: ToolDefinition[] = [
   },
   {
     name: 'n8n_update_partial_workflow',
-    description: `Update workflow incrementally with diff operations. Max 5 ops. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, updateSettings, updateName, add/removeTag. See tools_documentation("n8n_update_partial_workflow", "full") for details.`,
+    description: `Update workflow incrementally with diff operations. Types: addNode, removeNode, updateNode, moveNode, enable/disableNode, addConnection, removeConnection, updateSettings, updateName, add/removeTag. See tools_documentation("n8n_update_partial_workflow", "full") for details.`,
     inputSchema: {
       type: 'object',
       additionalProperties: true,  // Allow any extra properties Claude Desktop might add
@@ -180,6 +180,10 @@ export const n8nManagementTools: ToolDefinition[] = [
         validateOnly: {
           type: 'boolean',
           description: 'If true, only validate operations without applying them'
+        },
+        continueOnError: {
+          type: 'boolean',
+          description: 'If true, apply valid operations even if some fail (best-effort mode). Returns applied and failed operation indices. Default: false (atomic)'
         }
       },
       required: ['id', 'operations']
@@ -270,6 +274,41 @@ export const n8nManagementTools: ToolDefinition[] = [
       required: ['id']
     }
   },
+  {
+    name: 'n8n_autofix_workflow',
+    description: `Automatically fix common workflow validation errors. Preview fixes or apply them. Fixes expression format, typeVersion, error output config, webhook paths.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Workflow ID to fix'
+        },
+        applyFixes: {
+          type: 'boolean',
+          description: 'Apply fixes to workflow (default: false - preview mode)'
+        },
+        fixTypes: {
+          type: 'array',
+          description: 'Types of fixes to apply (default: all)',
+          items: {
+            type: 'string',
+            enum: ['expression-format', 'typeversion-correction', 'error-output-config', 'node-type-correction', 'webhook-missing-path']
+          }
+        },
+        confidenceThreshold: {
+          type: 'string',
+          enum: ['high', 'medium', 'low'],
+          description: 'Minimum confidence level for fixes (default: medium)'
+        },
+        maxFixes: {
+          type: 'number',
+          description: 'Maximum number of fixes to apply (default: 50)'
+        }
+      },
+      required: ['id']
+    }
+  },
 
   // Execution Management Tools
   {
@@ -305,17 +344,41 @@ export const n8nManagementTools: ToolDefinition[] = [
   },
   {
     name: 'n8n_get_execution',
-    description: `Get details of a specific execution by ID.`,
+    description: `Get execution details with smart filtering. RECOMMENDED: Use mode='preview' first to assess data size.
+Examples:
+- {id, mode:'preview'} - Structure & counts (fast, no data)
+- {id, mode:'summary'} - 2 samples per node (default)
+- {id, mode:'filtered', itemsLimit:5} - 5 items per node
+- {id, nodeNames:['HTTP Request']} - Specific node only
+- {id, mode:'full'} - Complete data (use with caution)`,
     inputSchema: {
       type: 'object',
       properties: {
-        id: { 
-          type: 'string', 
-          description: 'Execution ID' 
+        id: {
+          type: 'string',
+          description: 'Execution ID'
         },
-        includeData: { 
-          type: 'boolean', 
-          description: 'Include full execution data (default: false)' 
+        mode: {
+          type: 'string',
+          enum: ['preview', 'summary', 'filtered', 'full'],
+          description: 'Data retrieval mode: preview=structure only, summary=2 items, filtered=custom, full=all data'
+        },
+        nodeNames: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Filter to specific nodes by name (for filtered mode)'
+        },
+        itemsLimit: {
+          type: 'number',
+          description: 'Items per node: 0=structure only, 2=default, -1=unlimited (for filtered mode)'
+        },
+        includeInputData: {
+          type: 'boolean',
+          description: 'Include input data in addition to output (default: false)'
+        },
+        includeData: {
+          type: 'boolean',
+          description: 'Legacy: Include execution data. Maps to mode=summary if true (deprecated, use mode instead)'
         }
       },
       required: ['id']

src/mcp/tools.ts

@@ -73,7 +73,7 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
   },
   {
     name: 'search_nodes',
-    description: `Search n8n nodes by keyword. Pass query as string. Example: query="webhook" or query="database". Returns max 20 results.`,
+    description: `Search n8n nodes by keyword with optional real-world examples. Pass query as string. Example: query="webhook" or query="database". Returns max 20 results. Use includeExamples=true to get top 2 template configs per node.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -92,6 +92,11 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           description: 'OR=any word, AND=all words, FUZZY=typo-tolerant',
           default: 'OR',
         },
+        includeExamples: {
+          type: 'boolean',
+          description: 'Include top 2 real-world configuration examples from popular templates (default: false)',
+          default: false,
+        },
       },
       required: ['query'],
     },
@@ -128,7 +133,7 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
   },
   {
     name: 'get_node_essentials',
-    description: `Get node essential info. Pass nodeType as string with prefix. Example: nodeType="nodes-base.slack"`,
+    description: `Get node essential info with optional real-world examples from templates. Pass nodeType as string with prefix. Example: nodeType="nodes-base.slack". Use includeExamples=true to get top 3 template configs.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -136,6 +141,11 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
           type: 'string',
           description: 'Full type: "nodes-base.httpRequest"',
         },
+        includeExamples: {
+          type: 'boolean',
+          description: 'Include top 3 real-world configuration examples from popular templates (default: false)',
+          default: false,
+        },
       },
       required: ['nodeType'],
     },
@@ -163,20 +173,6 @@ export const n8nDocumentationToolsFinal: ToolDefinition[] = [
       required: ['nodeType', 'query'],
     },
   },
-  {
-    name: 'get_node_for_task',
-    description: `Get pre-configured node for tasks: post_json_request, receive_webhook, query_database, send_slack_message, etc. Use list_tasks for all.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        task: {
-          type: 'string',
-          description: 'Task name. See list_tasks for options.',
-        },
-      },
-      required: ['task'],
-    },
-  },
   {
     name: 'list_tasks',
     description: `List task templates by category: HTTP/API, Webhooks, Database, AI, Data Processing, Communication.`,

src/scripts/debug-http-search.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env npx tsx
+
+import { createDatabaseAdapter } from '../database/database-adapter';
+import { NodeRepository } from '../database/node-repository';
+import { NodeSimilarityService } from '../services/node-similarity-service';
+import path from 'path';
+
+async function debugHttpSearch() {
+  const dbPath = path.join(process.cwd(), 'data/nodes.db');
+  const db = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(db);
+  const service = new NodeSimilarityService(repository);
+
+  console.log('Testing "http" search...\n');
+
+  // Check if httpRequest exists
+  const httpNode = repository.getNode('nodes-base.httpRequest');
+  console.log('HTTP Request node exists:', httpNode ? 'Yes' : 'No');
+  if (httpNode) {
+    console.log('  Display name:', httpNode.displayName);
+  }
+
+  // Test the search with internal details
+  const suggestions = await service.findSimilarNodes('http', 5);
+  console.log('\nSuggestions for "http":', suggestions.length);
+  suggestions.forEach(s => {
+    console.log(`  - ${s.nodeType} (${Math.round(s.confidence * 100)}%)`);
+  });
+
+  // Manually calculate score for httpRequest
+  console.log('\nManual score calculation for httpRequest:');
+  const testNode = {
+    nodeType: 'nodes-base.httpRequest',
+    displayName: 'HTTP Request',
+    category: 'Core Nodes'
+  };
+
+  const cleanInvalid = 'http';
+  const cleanValid = 'nodesbasehttprequest';
+  const displayNameClean = 'httprequest';
+
+  // Check substring
+  const hasSubstring = cleanValid.includes(cleanInvalid) || displayNameClean.includes(cleanInvalid);
+  console.log(`  Substring match: ${hasSubstring}`);
+
+  // This should give us pattern match score
+  const patternScore = hasSubstring ? 35 : 0; // Using 35 for short searches
+  console.log(`  Pattern score: ${patternScore}`);
+
+  // Name similarity would be low
+  console.log(`  Total score would need to be >= 50 to appear`);
+
+  // Get all nodes and check which ones contain 'http'
+  const allNodes = repository.getAllNodes();
+  const httpNodes = allNodes.filter(n =>
+    n.nodeType.toLowerCase().includes('http') ||
+    (n.displayName && n.displayName.toLowerCase().includes('http'))
+  );
+
+  console.log('\n\nNodes containing "http" in name:');
+  httpNodes.slice(0, 5).forEach(n => {
+    console.log(`  - ${n.nodeType} (${n.displayName})`);
+
+    // Calculate score for this node
+    const normalizedSearch = 'http';
+    const normalizedType = n.nodeType.toLowerCase().replace(/[^a-z0-9]/g, '');
+    const normalizedDisplay = (n.displayName || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+
+    const containsInType = normalizedType.includes(normalizedSearch);
+    const containsInDisplay = normalizedDisplay.includes(normalizedSearch);
+
+    console.log(`    Type check: "${normalizedType}" includes "${normalizedSearch}" = ${containsInType}`);
+    console.log(`    Display check: "${normalizedDisplay}" includes "${normalizedSearch}" = ${containsInDisplay}`);
+  });
+}
+
+debugHttpSearch().catch(console.error);

src/scripts/fetch-templates.ts

@@ -10,21 +10,240 @@ import type { MetadataRequest } from '../templates/metadata-generator';
 // Load environment variables
 dotenv.config();
 
-async function fetchTemplates(mode: 'rebuild' | 'update' = 'rebuild', generateMetadata: boolean = false, metadataOnly: boolean = false) {
+/**
+ * Extract node configurations from a template workflow
+ */
+function extractNodeConfigs(
+  templateId: number,
+  templateName: string,
+  templateViews: number,
+  workflowCompressed: string,
+  metadata: any
+): Array<{
+  node_type: string;
+  template_id: number;
+  template_name: string;
+  template_views: number;
+  node_name: string;
+  parameters_json: string;
+  credentials_json: string | null;
+  has_credentials: number;
+  has_expressions: number;
+  complexity: string;
+  use_cases: string;
+}> {
+  try {
+    // Decompress workflow
+    const decompressed = zlib.gunzipSync(Buffer.from(workflowCompressed, 'base64'));
+    const workflow = JSON.parse(decompressed.toString('utf-8'));
+
+    const configs: any[] = [];
+
+    for (const node of workflow.nodes || []) {
+      // Skip UI-only nodes (sticky notes, etc.)
+      if (node.type.includes('stickyNote') || !node.parameters) {
+        continue;
+      }
+
+      configs.push({
+        node_type: node.type,
+        template_id: templateId,
+        template_name: templateName,
+        template_views: templateViews,
+        node_name: node.name,
+        parameters_json: JSON.stringify(node.parameters),
+        credentials_json: node.credentials ? JSON.stringify(node.credentials) : null,
+        has_credentials: node.credentials ? 1 : 0,
+        has_expressions: detectExpressions(node.parameters) ? 1 : 0,
+        complexity: metadata?.complexity || 'medium',
+        use_cases: JSON.stringify(metadata?.use_cases || [])
+      });
+    }
+
+    return configs;
+  } catch (error) {
+    console.error(`Error extracting configs from template ${templateId}:`, error);
+    return [];
+  }
+}
+
+/**
+ * Detect n8n expressions in parameters
+ */
+function detectExpressions(params: any): boolean {
+  if (!params) return false;
+  const json = JSON.stringify(params);
+  return json.includes('={{') || json.includes('$json') || json.includes('$node');
+}
+
+/**
+ * Insert extracted configs into database and rank them
+ */
+function insertAndRankConfigs(db: any, configs: any[]) {
+  if (configs.length === 0) {
+    console.log('No configs to insert');
+    return;
+  }
+
+  // Clear old configs for these templates
+  const templateIds = [...new Set(configs.map(c => c.template_id))];
+  const placeholders = templateIds.map(() => '?').join(',');
+  db.prepare(`DELETE FROM template_node_configs WHERE template_id IN (${placeholders})`).run(...templateIds);
+
+  // Insert new configs
+  const insertStmt = db.prepare(`
+    INSERT INTO template_node_configs (
+      node_type, template_id, template_name, template_views,
+      node_name, parameters_json, credentials_json,
+      has_credentials, has_expressions, complexity, use_cases
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  for (const config of configs) {
+    insertStmt.run(
+      config.node_type,
+      config.template_id,
+      config.template_name,
+      config.template_views,
+      config.node_name,
+      config.parameters_json,
+      config.credentials_json,
+      config.has_credentials,
+      config.has_expressions,
+      config.complexity,
+      config.use_cases
+    );
+  }
+
+  // Rank configs per node_type by template popularity
+  db.exec(`
+    UPDATE template_node_configs
+    SET rank = (
+      SELECT COUNT(*) + 1
+      FROM template_node_configs AS t2
+      WHERE t2.node_type = template_node_configs.node_type
+        AND t2.template_views > template_node_configs.template_views
+    )
+  `);
+
+  // Keep only top 10 per node_type
+  db.exec(`
+    DELETE FROM template_node_configs
+    WHERE id NOT IN (
+      SELECT id FROM template_node_configs
+      WHERE rank <= 10
+      ORDER BY node_type, rank
+    )
+  `);
+
+  console.log(`✅ Extracted and ranked ${configs.length} node configurations`);
+}
+
+/**
+ * Extract node configurations from existing templates
+ */
+async function extractTemplateConfigs(db: any, service: TemplateService) {
+  console.log('📦 Extracting node configurations from templates...');
+  const repository = (service as any).repository;
+  const allTemplates = repository.getAllTemplates();
+
+  const allConfigs: any[] = [];
+  let configsExtracted = 0;
+
+  for (const template of allTemplates) {
+    if (template.workflow_json_compressed) {
+      const metadata = template.metadata_json ? JSON.parse(template.metadata_json) : null;
+      const configs = extractNodeConfigs(
+        template.id,
+        template.name,
+        template.views,
+        template.workflow_json_compressed,
+        metadata
+      );
+      allConfigs.push(...configs);
+      configsExtracted += configs.length;
+    }
+  }
+
+  if (allConfigs.length > 0) {
+    insertAndRankConfigs(db, allConfigs);
+
+    // Show stats
+    const configStats = db.prepare(`
+      SELECT
+        COUNT(DISTINCT node_type) as node_types,
+        COUNT(*) as total_configs,
+        AVG(rank) as avg_rank
+      FROM template_node_configs
+    `).get() as any;
+
+    console.log(`📊 Node config stats:`);
+    console.log(`   - Unique node types: ${configStats.node_types}`);
+    console.log(`   - Total configs stored: ${configStats.total_configs}`);
+    console.log(`   - Average rank: ${configStats.avg_rank?.toFixed(1) || 'N/A'}`);
+  } else {
+    console.log('⚠️  No node configurations extracted');
+  }
+}
+
+async function fetchTemplates(
+  mode: 'rebuild' | 'update' = 'rebuild',
+  generateMetadata: boolean = false,
+  metadataOnly: boolean = false,
+  extractOnly: boolean = false
+) {
+  // If extract-only mode, skip template fetching and only extract configs
+  if (extractOnly) {
+    console.log('📦 Extract-only mode: Extracting node configurations from existing templates...\n');
+
+    const db = await createDatabaseAdapter('./data/nodes.db');
+
+    // Ensure template_node_configs table exists
+    try {
+      const tableExists = db.prepare(`
+        SELECT name FROM sqlite_master
+        WHERE type='table' AND name='template_node_configs'
+      `).get();
+
+      if (!tableExists) {
+        console.log('📋 Creating template_node_configs table...');
+        const migrationPath = path.join(__dirname, '../../src/database/migrations/add-template-node-configs.sql');
+        const migration = fs.readFileSync(migrationPath, 'utf8');
+        db.exec(migration);
+        console.log('✅ Table created successfully\n');
+      }
+    } catch (error) {
+      console.error('❌ Error checking/creating template_node_configs table:', error);
+      if ('close' in db && typeof db.close === 'function') {
+        db.close();
+      }
+      process.exit(1);
+    }
+
+    const service = new TemplateService(db);
+
+    await extractTemplateConfigs(db, service);
+
+    if ('close' in db && typeof db.close === 'function') {
+      db.close();
+    }
+    return;
+  }
+
   // If metadata-only mode, skip template fetching entirely
   if (metadataOnly) {
     console.log('🤖 Metadata-only mode: Generating metadata for existing templates...\n');
-    
+
     if (!process.env.OPENAI_API_KEY) {
       console.error('❌ OPENAI_API_KEY not set in environment');
       process.exit(1);
     }
-    
+
     const db = await createDatabaseAdapter('./data/nodes.db');
     const service = new TemplateService(db);
-    
+
     await generateTemplateMetadata(db, service);
-    
+
     if ('close' in db && typeof db.close === 'function') {
       db.close();
     }
@@ -125,7 +344,11 @@ async function fetchTemplates(mode: 'rebuild' | 'update' = 'rebuild', generateMe
     stats.topUsedNodes.forEach((node: any, index: number) => {
       console.log(`   ${index + 1}. ${node.node} (${node.count} templates)`);
     });
-    
+
+    // Extract node configurations from templates
+    console.log('');
+    await extractTemplateConfigs(db, service);
+
     // Generate metadata if requested
     if (generateMetadata && process.env.OPENAI_API_KEY) {
       console.log('\n🤖 Generating metadata for templates...');
@@ -133,7 +356,7 @@ async function fetchTemplates(mode: 'rebuild' | 'update' = 'rebuild', generateMe
     } else if (generateMetadata && !process.env.OPENAI_API_KEY) {
       console.log('\n⚠️  Metadata generation requested but OPENAI_API_KEY not set');
     }
-    
+
   } catch (error) {
     console.error('\n❌ Error fetching templates:', error);
     process.exit(1);
@@ -237,39 +460,45 @@ async function generateTemplateMetadata(db: any, service: TemplateService) {
 }
 
 // Parse command line arguments
-function parseArgs(): { mode: 'rebuild' | 'update', generateMetadata: boolean, metadataOnly: boolean } {
+function parseArgs(): { mode: 'rebuild' | 'update', generateMetadata: boolean, metadataOnly: boolean, extractOnly: boolean } {
   const args = process.argv.slice(2);
-  
+
   let mode: 'rebuild' | 'update' = 'rebuild';
   let generateMetadata = false;
   let metadataOnly = false;
-  
+  let extractOnly = false;
+
   // Check for --mode flag
   const modeIndex = args.findIndex(arg => arg.startsWith('--mode'));
   if (modeIndex !== -1) {
     const modeArg = args[modeIndex];
     const modeValue = modeArg.includes('=') ? modeArg.split('=')[1] : args[modeIndex + 1];
-    
+
     if (modeValue === 'update') {
       mode = 'update';
     }
   }
-  
+
   // Check for --update flag as shorthand
   if (args.includes('--update')) {
     mode = 'update';
   }
-  
+
   // Check for --generate-metadata flag
   if (args.includes('--generate-metadata') || args.includes('--metadata')) {
     generateMetadata = true;
   }
-  
+
   // Check for --metadata-only flag
   if (args.includes('--metadata-only')) {
     metadataOnly = true;
   }
-  
+
+  // Check for --extract-only flag
+  if (args.includes('--extract-only') || args.includes('--extract')) {
+    extractOnly = true;
+  }
+
   // Show help if requested
   if (args.includes('--help') || args.includes('-h')) {
     console.log('Usage: npm run fetch:templates [options]\n');
@@ -279,17 +508,19 @@ function parseArgs(): { mode: 'rebuild' | 'update', generateMetadata: boolean, m
     console.log('  --generate-metadata    Generate AI metadata after fetching templates');
     console.log('  --metadata             Shorthand for --generate-metadata');
     console.log('  --metadata-only        Only generate metadata, skip template fetching');
+    console.log('  --extract-only         Only extract node configs, skip template fetching');
+    console.log('  --extract              Shorthand for --extract-only');
     console.log('  --help, -h             Show this help message');
     process.exit(0);
   }
-  
-  return { mode, generateMetadata, metadataOnly };
+
+  return { mode, generateMetadata, metadataOnly, extractOnly };
 }
 
 // Run if called directly
 if (require.main === module) {
-  const { mode, generateMetadata, metadataOnly } = parseArgs();
-  fetchTemplates(mode, generateMetadata, metadataOnly).catch(console.error);
+  const { mode, generateMetadata, metadataOnly, extractOnly } = parseArgs();
+  fetchTemplates(mode, generateMetadata, metadataOnly, extractOnly).catch(console.error);
 }
 
 export { fetchTemplates };

src/scripts/sanitize-templates.ts

@@ -2,40 +2,75 @@
 import { createDatabaseAdapter } from '../database/database-adapter';
 import { logger } from '../utils/logger';
 import { TemplateSanitizer } from '../utils/template-sanitizer';
+import { gunzipSync, gzipSync } from 'zlib';
 
 async function sanitizeTemplates() {
   console.log('🧹 Sanitizing workflow templates in database...\n');
-  
+
   const db = await createDatabaseAdapter('./data/nodes.db');
   const sanitizer = new TemplateSanitizer();
-  
+
   try {
-    // Get all templates
-    const templates = db.prepare('SELECT id, name, workflow_json FROM templates').all() as any[];
+    // Get all templates - check both old and new format
+    const templates = db.prepare('SELECT id, name, workflow_json, workflow_json_compressed FROM templates').all() as any[];
     console.log(`Found ${templates.length} templates to check\n`);
-    
+
     let sanitizedCount = 0;
     const problematicTemplates: any[] = [];
-    
+
     for (const template of templates) {
-      const originalWorkflow = JSON.parse(template.workflow_json);
+      let originalWorkflow: any = null;
+      let useCompressed = false;
+
+      // Try compressed format first (newer format)
+      if (template.workflow_json_compressed) {
+        try {
+          const buffer = Buffer.from(template.workflow_json_compressed, 'base64');
+          const decompressed = gunzipSync(buffer).toString('utf-8');
+          originalWorkflow = JSON.parse(decompressed);
+          useCompressed = true;
+        } catch (e) {
+          console.log(`⚠️ Failed to decompress template ${template.id}, trying uncompressed`);
+        }
+      }
+
+      // Fall back to uncompressed format (deprecated)
+      if (!originalWorkflow && template.workflow_json) {
+        try {
+          originalWorkflow = JSON.parse(template.workflow_json);
+        } catch (e) {
+          console.log(`⚠️ Skipping template ${template.id}: Invalid JSON in both formats`);
+          continue;
+        }
+      }
+
+      if (!originalWorkflow) {
+        continue; // Skip templates without workflow data
+      }
+
       const { sanitized: sanitizedWorkflow, wasModified } = sanitizer.sanitizeWorkflow(originalWorkflow);
-      
+
       if (wasModified) {
         // Get detected tokens for reporting
         const detectedTokens = sanitizer.detectTokens(originalWorkflow);
-        
-        // Update the template with sanitized version
-        const stmt = db.prepare('UPDATE templates SET workflow_json = ? WHERE id = ?');
-        stmt.run(JSON.stringify(sanitizedWorkflow), template.id);
-        
+
+        // Update the template with sanitized version in the same format
+        if (useCompressed) {
+          const compressed = gzipSync(JSON.stringify(sanitizedWorkflow)).toString('base64');
+          const stmt = db.prepare('UPDATE templates SET workflow_json_compressed = ? WHERE id = ?');
+          stmt.run(compressed, template.id);
+        } else {
+          const stmt = db.prepare('UPDATE templates SET workflow_json = ? WHERE id = ?');
+          stmt.run(JSON.stringify(sanitizedWorkflow), template.id);
+        }
+
         sanitizedCount++;
         problematicTemplates.push({
           id: template.id,
           name: template.name,
           tokens: detectedTokens
         });
-        
+
         console.log(`✅ Sanitized template ${template.id}: ${template.name}`);
         detectedTokens.forEach(token => {
           console.log(`   - Found: ${token.substring(0, 20)}...`);

src/scripts/test-autofix-documentation.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Test script to verify n8n_autofix_workflow documentation is properly integrated
+ */
+
+import { toolsDocumentation } from '../mcp/tool-docs';
+import { getToolDocumentation } from '../mcp/tools-documentation';
+import { Logger } from '../utils/logger';
+
+const logger = new Logger({ prefix: '[AutofixDoc Test]' });
+
+async function testAutofixDocumentation() {
+  logger.info('Testing n8n_autofix_workflow documentation...\n');
+
+  // Test 1: Check if documentation exists in the registry
+  logger.info('Test 1: Checking documentation registry');
+  const hasDoc = 'n8n_autofix_workflow' in toolsDocumentation;
+  if (hasDoc) {
+    logger.info('✅ Documentation found in registry');
+  } else {
+    logger.error('❌ Documentation NOT found in registry');
+    logger.info('Available tools:', Object.keys(toolsDocumentation).filter(k => k.includes('autofix')));
+  }
+
+  // Test 2: Check documentation structure
+  if (hasDoc) {
+    logger.info('\nTest 2: Checking documentation structure');
+    const doc = toolsDocumentation['n8n_autofix_workflow'];
+
+    const hasEssentials = doc.essentials &&
+                         doc.essentials.description &&
+                         doc.essentials.keyParameters &&
+                         doc.essentials.example;
+
+    const hasFull = doc.full &&
+                   doc.full.description &&
+                   doc.full.parameters &&
+                   doc.full.examples;
+
+    if (hasEssentials) {
+      logger.info('✅ Essentials documentation complete');
+      logger.info(`  Description: ${doc.essentials.description.substring(0, 80)}...`);
+      logger.info(`  Key params: ${doc.essentials.keyParameters.join(', ')}`);
+    } else {
+      logger.error('❌ Essentials documentation incomplete');
+    }
+
+    if (hasFull) {
+      logger.info('✅ Full documentation complete');
+      logger.info(`  Parameters: ${Object.keys(doc.full.parameters).join(', ')}`);
+      logger.info(`  Examples: ${doc.full.examples.length} provided`);
+    } else {
+      logger.error('❌ Full documentation incomplete');
+    }
+  }
+
+  // Test 3: Test getToolDocumentation function
+  logger.info('\nTest 3: Testing getToolDocumentation function');
+
+  try {
+    const essentialsDoc = getToolDocumentation('n8n_autofix_workflow', 'essentials');
+    if (essentialsDoc.includes("Tool 'n8n_autofix_workflow' not found")) {
+      logger.error('❌ Essentials documentation retrieval failed');
+    } else {
+      logger.info('✅ Essentials documentation retrieved');
+      const lines = essentialsDoc.split('\n').slice(0, 3);
+      lines.forEach(line => logger.info(`  ${line}`));
+    }
+  } catch (error) {
+    logger.error('❌ Error retrieving essentials documentation:', error);
+  }
+
+  try {
+    const fullDoc = getToolDocumentation('n8n_autofix_workflow', 'full');
+    if (fullDoc.includes("Tool 'n8n_autofix_workflow' not found")) {
+      logger.error('❌ Full documentation retrieval failed');
+    } else {
+      logger.info('✅ Full documentation retrieved');
+      const lines = fullDoc.split('\n').slice(0, 3);
+      lines.forEach(line => logger.info(`  ${line}`));
+    }
+  } catch (error) {
+    logger.error('❌ Error retrieving full documentation:', error);
+  }
+
+  // Test 4: Check if tool is listed in workflow management tools
+  logger.info('\nTest 4: Checking workflow management tools listing');
+  const workflowTools = Object.keys(toolsDocumentation).filter(k => k.startsWith('n8n_'));
+  const hasAutofix = workflowTools.includes('n8n_autofix_workflow');
+
+  if (hasAutofix) {
+    logger.info('✅ n8n_autofix_workflow is listed in workflow management tools');
+    logger.info(`  Total workflow tools: ${workflowTools.length}`);
+
+    // Show related tools
+    const relatedTools = workflowTools.filter(t =>
+      t.includes('validate') || t.includes('update') || t.includes('fix')
+    );
+    logger.info(`  Related tools: ${relatedTools.join(', ')}`);
+  } else {
+    logger.error('❌ n8n_autofix_workflow NOT listed in workflow management tools');
+  }
+
+  // Summary
+  logger.info('\n' + '='.repeat(60));
+  logger.info('Summary:');
+
+  if (hasDoc && hasAutofix) {
+    logger.info('✨ Documentation integration successful!');
+    logger.info('The n8n_autofix_workflow tool documentation is properly integrated.');
+    logger.info('\nTo use in MCP:');
+    logger.info('  - Essentials: tools_documentation({topic: "n8n_autofix_workflow"})');
+    logger.info('  - Full: tools_documentation({topic: "n8n_autofix_workflow", depth: "full"})');
+  } else {
+    logger.error('⚠️ Documentation integration incomplete');
+    logger.info('Please check the implementation and rebuild the project.');
+  }
+}
+
+testAutofixDocumentation().catch(console.error);

src/scripts/test-autofix-workflow.ts

@@ -0,0 +1,251 @@
+/**
+ * Test script for n8n_autofix_workflow functionality
+ *
+ * Tests the automatic fixing of common workflow validation errors:
+ * 1. Expression format errors (missing = prefix)
+ * 2. TypeVersion corrections
+ * 3. Error output configuration issues
+ */
+
+import { WorkflowAutoFixer } from '../services/workflow-auto-fixer';
+import { WorkflowValidator } from '../services/workflow-validator';
+import { EnhancedConfigValidator } from '../services/enhanced-config-validator';
+import { ExpressionFormatValidator } from '../services/expression-format-validator';
+import { NodeRepository } from '../database/node-repository';
+import { Logger } from '../utils/logger';
+import { createDatabaseAdapter } from '../database/database-adapter';
+import * as path from 'path';
+
+const logger = new Logger({ prefix: '[TestAutofix]' });
+
+async function testAutofix() {
+  // Initialize database and repository
+  const dbPath = path.join(__dirname, '../../data/nodes.db');
+  const dbAdapter = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(dbAdapter);
+
+  // Test workflow with various issues
+  const testWorkflow = {
+    id: 'test_workflow_1',
+    name: 'Test Workflow for Autofix',
+    nodes: [
+      {
+        id: 'webhook_1',
+        name: 'Webhook',
+        type: 'n8n-nodes-base.webhook',
+        typeVersion: 1.1,
+        position: [250, 300],
+        parameters: {
+          httpMethod: 'GET',
+          path: 'test-webhook',
+          responseMode: 'onReceived',
+          responseData: 'firstEntryJson'
+        }
+      },
+      {
+        id: 'http_1',
+        name: 'HTTP Request',
+        type: 'n8n-nodes-base.httpRequest',
+        typeVersion: 5.0, // Invalid - max is 4.2
+        position: [450, 300],
+        parameters: {
+          method: 'GET',
+          url: '{{ $json.webhookUrl }}', // Missing = prefix
+          sendHeaders: true,
+          headerParameters: {
+            parameters: [
+              {
+                name: 'Authorization',
+                value: '{{ $json.token }}' // Missing = prefix
+              }
+            ]
+          }
+        },
+        onError: 'continueErrorOutput' // Has onError but no error connections
+      },
+      {
+        id: 'set_1',
+        name: 'Set',
+        type: 'n8n-nodes-base.set',
+        typeVersion: 3.5, // Invalid version
+        position: [650, 300],
+        parameters: {
+          mode: 'manual',
+          duplicateItem: false,
+          values: {
+            values: [
+              {
+                name: 'status',
+                value: '{{ $json.success }}' // Missing = prefix
+              }
+            ]
+          }
+        }
+      }
+    ],
+    connections: {
+      'Webhook': {
+        main: [
+          [
+            {
+              node: 'HTTP Request',
+              type: 'main',
+              index: 0
+            }
+          ]
+        ]
+      },
+      'HTTP Request': {
+        main: [
+          [
+            {
+              node: 'Set',
+              type: 'main',
+              index: 0
+            }
+          ]
+          // Missing error output connection for onError: 'continueErrorOutput'
+        ]
+      }
+    }
+  };
+
+  logger.info('=== Testing Workflow Auto-Fixer ===\n');
+
+  // Step 1: Validate the workflow to identify issues
+  logger.info('Step 1: Validating workflow to identify issues...');
+  const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+  const validationResult = await validator.validateWorkflow(testWorkflow as any, {
+    validateNodes: true,
+    validateConnections: true,
+    validateExpressions: true,
+    profile: 'ai-friendly'
+  });
+
+  logger.info(`Found ${validationResult.errors.length} errors and ${validationResult.warnings.length} warnings`);
+
+  // Step 2: Check for expression format issues
+  logger.info('\nStep 2: Checking for expression format issues...');
+  const allFormatIssues: any[] = [];
+  for (const node of testWorkflow.nodes) {
+    const formatContext = {
+      nodeType: node.type,
+      nodeName: node.name,
+      nodeId: node.id
+    };
+
+    const nodeFormatIssues = ExpressionFormatValidator.validateNodeParameters(
+      node.parameters,
+      formatContext
+    );
+
+    // Add node information to each format issue
+    const enrichedIssues = nodeFormatIssues.map(issue => ({
+      ...issue,
+      nodeName: node.name,
+      nodeId: node.id
+    }));
+
+    allFormatIssues.push(...enrichedIssues);
+  }
+
+  logger.info(`Found ${allFormatIssues.length} expression format issues`);
+
+  // Debug: Show the actual format issues
+  if (allFormatIssues.length > 0) {
+    logger.info('\nExpression format issues found:');
+    for (const issue of allFormatIssues) {
+      logger.info(`  - ${issue.fieldPath}: ${issue.issueType} (${issue.severity})`);
+      logger.info(`    Current: ${JSON.stringify(issue.currentValue)}`);
+      logger.info(`    Fixed: ${JSON.stringify(issue.correctedValue)}`);
+    }
+  }
+
+  // Step 3: Generate fixes in preview mode
+  logger.info('\nStep 3: Generating fixes (preview mode)...');
+  const autoFixer = new WorkflowAutoFixer();
+  const previewResult = autoFixer.generateFixes(
+    testWorkflow as any,
+    validationResult,
+    allFormatIssues,
+    {
+      applyFixes: false, // Preview mode
+      confidenceThreshold: 'medium'
+    }
+  );
+
+  logger.info(`\nGenerated ${previewResult.fixes.length} fixes:`);
+  logger.info(`Summary: ${previewResult.summary}`);
+  logger.info('\nFixes by type:');
+  for (const [type, count] of Object.entries(previewResult.stats.byType)) {
+    if (count > 0) {
+      logger.info(`  - ${type}: ${count}`);
+    }
+  }
+
+  logger.info('\nFixes by confidence:');
+  for (const [confidence, count] of Object.entries(previewResult.stats.byConfidence)) {
+    if (count > 0) {
+      logger.info(`  - ${confidence}: ${count}`);
+    }
+  }
+
+  // Step 4: Display individual fixes
+  logger.info('\nDetailed fixes:');
+  for (const fix of previewResult.fixes) {
+    logger.info(`\n[${fix.confidence.toUpperCase()}] ${fix.node}.${fix.field} (${fix.type})`);
+    logger.info(`  Before: ${JSON.stringify(fix.before)}`);
+    logger.info(`  After:  ${JSON.stringify(fix.after)}`);
+    logger.info(`  Description: ${fix.description}`);
+  }
+
+  // Step 5: Display generated operations
+  logger.info('\n\nGenerated diff operations:');
+  for (const op of previewResult.operations) {
+    logger.info(`\nOperation: ${op.type}`);
+    logger.info(`  Details: ${JSON.stringify(op, null, 2)}`);
+  }
+
+  // Step 6: Test with different confidence thresholds
+  logger.info('\n\n=== Testing Different Confidence Thresholds ===');
+
+  for (const threshold of ['high', 'medium', 'low'] as const) {
+    const result = autoFixer.generateFixes(
+      testWorkflow as any,
+      validationResult,
+      allFormatIssues,
+      {
+        applyFixes: false,
+        confidenceThreshold: threshold
+      }
+    );
+    logger.info(`\nThreshold "${threshold}": ${result.fixes.length} fixes`);
+  }
+
+  // Step 7: Test with specific fix types
+  logger.info('\n\n=== Testing Specific Fix Types ===');
+
+  const fixTypes = ['expression-format', 'typeversion-correction', 'error-output-config'] as const;
+  for (const fixType of fixTypes) {
+    const result = autoFixer.generateFixes(
+      testWorkflow as any,
+      validationResult,
+      allFormatIssues,
+      {
+        applyFixes: false,
+        fixTypes: [fixType]
+      }
+    );
+    logger.info(`\nFix type "${fixType}": ${result.fixes.length} fixes`);
+  }
+
+  logger.info('\n\n✅ Autofix test completed successfully!');
+
+  await dbAdapter.close();
+}
+
+// Run the test
+testAutofix().catch(error => {
+  logger.error('Test failed:', error);
+  process.exit(1);
+});

src/scripts/test-execution-filtering.ts

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+/**
+ * Manual testing script for execution filtering feature
+ *
+ * This script demonstrates all modes of the n8n_get_execution tool
+ * with various filtering options.
+ *
+ * Usage: npx tsx src/scripts/test-execution-filtering.ts
+ */
+
+import {
+  generatePreview,
+  filterExecutionData,
+  processExecution,
+} from '../services/execution-processor';
+import { ExecutionFilterOptions, Execution, ExecutionStatus } from '../types/n8n-api';
+
+console.log('='.repeat(80));
+console.log('Execution Filtering Feature - Manual Test Suite');
+console.log('='.repeat(80));
+console.log('');
+
+/**
+ * Mock execution factory (simplified version for testing)
+ */
+function createTestExecution(itemCount: number): Execution {
+  const items = Array.from({ length: itemCount }, (_, i) => ({
+    json: {
+      id: i + 1,
+      name: `Item ${i + 1}`,
+      email: `user${i}@example.com`,
+      value: Math.random() * 1000,
+      metadata: {
+        createdAt: new Date().toISOString(),
+        tags: ['tag1', 'tag2'],
+      },
+    },
+  }));
+
+  return {
+    id: `test-exec-${Date.now()}`,
+    workflowId: 'workflow-test',
+    status: ExecutionStatus.SUCCESS,
+    mode: 'manual',
+    finished: true,
+    startedAt: '2024-01-01T10:00:00.000Z',
+    stoppedAt: '2024-01-01T10:00:05.000Z',
+    data: {
+      resultData: {
+        runData: {
+          'HTTP Request': [
+            {
+              startTime: Date.now(),
+              executionTime: 234,
+              data: {
+                main: [items],
+              },
+            },
+          ],
+          'Filter': [
+            {
+              startTime: Date.now(),
+              executionTime: 45,
+              data: {
+                main: [items.slice(0, Math.floor(itemCount / 2))],
+              },
+            },
+          ],
+          'Set': [
+            {
+              startTime: Date.now(),
+              executionTime: 12,
+              data: {
+                main: [items.slice(0, 5)],
+              },
+            },
+          ],
+        },
+      },
+    },
+  };
+}
+
+/**
+ * Test 1: Preview Mode
+ */
+console.log('📊 TEST 1: Preview Mode (No Data, Just Structure)');
+console.log('-'.repeat(80));
+
+const execution1 = createTestExecution(50);
+const { preview, recommendation } = generatePreview(execution1);
+
+console.log('Preview:', JSON.stringify(preview, null, 2));
+console.log('\nRecommendation:', JSON.stringify(recommendation, null, 2));
+console.log('\n✅ Preview mode shows structure without consuming tokens for data\n');
+
+/**
+ * Test 2: Summary Mode (Default)
+ */
+console.log('📝 TEST 2: Summary Mode (2 items per node)');
+console.log('-'.repeat(80));
+
+const execution2 = createTestExecution(50);
+const summaryResult = filterExecutionData(execution2, { mode: 'summary' });
+
+console.log('Summary Mode Result:');
+console.log('- Mode:', summaryResult.mode);
+console.log('- Summary:', JSON.stringify(summaryResult.summary, null, 2));
+console.log('- HTTP Request items shown:', summaryResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown);
+console.log('- HTTP Request truncated:', summaryResult.nodes?.['HTTP Request']?.data?.metadata.truncated);
+console.log('\n✅ Summary mode returns 2 items per node (safe default)\n');
+
+/**
+ * Test 3: Filtered Mode with Custom Limit
+ */
+console.log('🎯 TEST 3: Filtered Mode (Custom itemsLimit: 5)');
+console.log('-'.repeat(80));
+
+const execution3 = createTestExecution(100);
+const filteredResult = filterExecutionData(execution3, {
+  mode: 'filtered',
+  itemsLimit: 5,
+});
+
+console.log('Filtered Mode Result:');
+console.log('- Items shown per node:', filteredResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown);
+console.log('- Total items available:', filteredResult.nodes?.['HTTP Request']?.data?.metadata.totalItems);
+console.log('- More data available:', filteredResult.summary?.hasMoreData);
+console.log('\n✅ Filtered mode allows custom item limits\n');
+
+/**
+ * Test 4: Node Name Filtering
+ */
+console.log('🔍 TEST 4: Filter to Specific Nodes');
+console.log('-'.repeat(80));
+
+const execution4 = createTestExecution(30);
+const nodeFilterResult = filterExecutionData(execution4, {
+  mode: 'filtered',
+  nodeNames: ['HTTP Request'],
+  itemsLimit: 3,
+});
+
+console.log('Node Filter Result:');
+console.log('- Nodes in result:', Object.keys(nodeFilterResult.nodes || {}));
+console.log('- Expected: ["HTTP Request"]');
+console.log('- Executed nodes:', nodeFilterResult.summary?.executedNodes);
+console.log('- Total nodes:', nodeFilterResult.summary?.totalNodes);
+console.log('\n✅ Can filter to specific nodes only\n');
+
+/**
+ * Test 5: Structure-Only Mode (itemsLimit: 0)
+ */
+console.log('🏗️  TEST 5: Structure-Only Mode (itemsLimit: 0)');
+console.log('-'.repeat(80));
+
+const execution5 = createTestExecution(100);
+const structureResult = filterExecutionData(execution5, {
+  mode: 'filtered',
+  itemsLimit: 0,
+});
+
+console.log('Structure-Only Result:');
+console.log('- Items shown:', structureResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown);
+console.log('- First item (structure):', JSON.stringify(
+  structureResult.nodes?.['HTTP Request']?.data?.output?.[0]?.[0],
+  null,
+  2
+));
+console.log('\n✅ Structure-only mode shows data shape without values\n');
+
+/**
+ * Test 6: Full Mode
+ */
+console.log('💾 TEST 6: Full Mode (All Data)');
+console.log('-'.repeat(80));
+
+const execution6 = createTestExecution(5); // Small dataset
+const fullResult = filterExecutionData(execution6, { mode: 'full' });
+
+console.log('Full Mode Result:');
+console.log('- Items shown:', fullResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown);
+console.log('- Total items:', fullResult.nodes?.['HTTP Request']?.data?.metadata.totalItems);
+console.log('- Truncated:', fullResult.nodes?.['HTTP Request']?.data?.metadata.truncated);
+console.log('\n✅ Full mode returns all data (use with caution)\n');
+
+/**
+ * Test 7: Backward Compatibility
+ */
+console.log('🔄 TEST 7: Backward Compatibility (No Filtering)');
+console.log('-'.repeat(80));
+
+const execution7 = createTestExecution(10);
+const legacyResult = processExecution(execution7, {});
+
+console.log('Legacy Result:');
+console.log('- Returns original execution:', legacyResult === execution7);
+console.log('- Type:', typeof legacyResult);
+console.log('\n✅ Backward compatible - no options returns original execution\n');
+
+/**
+ * Test 8: Input Data Inclusion
+ */
+console.log('🔗 TEST 8: Include Input Data');
+console.log('-'.repeat(80));
+
+const execution8 = createTestExecution(5);
+const inputDataResult = filterExecutionData(execution8, {
+  mode: 'filtered',
+  itemsLimit: 2,
+  includeInputData: true,
+});
+
+console.log('Input Data Result:');
+console.log('- Has input data:', !!inputDataResult.nodes?.['HTTP Request']?.data?.input);
+console.log('- Has output data:', !!inputDataResult.nodes?.['HTTP Request']?.data?.output);
+console.log('\n✅ Can include input data for debugging\n');
+
+/**
+ * Test 9: itemsLimit Validation
+ */
+console.log('⚠️  TEST 9: itemsLimit Validation');
+console.log('-'.repeat(80));
+
+const execution9 = createTestExecution(50);
+
+// Test negative value
+const negativeResult = filterExecutionData(execution9, {
+  mode: 'filtered',
+  itemsLimit: -5,
+});
+console.log('- Negative itemsLimit (-5) handled:', negativeResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown === 2);
+
+// Test very large value
+const largeResult = filterExecutionData(execution9, {
+  mode: 'filtered',
+  itemsLimit: 999999,
+});
+console.log('- Large itemsLimit (999999) capped:', (largeResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown || 0) <= 1000);
+
+// Test unlimited (-1)
+const unlimitedResult = filterExecutionData(execution9, {
+  mode: 'filtered',
+  itemsLimit: -1,
+});
+console.log('- Unlimited itemsLimit (-1) works:', unlimitedResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown === 50);
+
+console.log('\n✅ itemsLimit validation works correctly\n');
+
+/**
+ * Test 10: Recommendation Following
+ */
+console.log('🎯 TEST 10: Follow Recommendation Workflow');
+console.log('-'.repeat(80));
+
+const execution10 = createTestExecution(100);
+const { preview: preview10, recommendation: rec10 } = generatePreview(execution10);
+
+console.log('1. Preview shows:', {
+  totalItems: preview10.nodes['HTTP Request']?.itemCounts.output,
+  sizeKB: preview10.estimatedSizeKB,
+});
+
+console.log('\n2. Recommendation:', {
+  canFetchFull: rec10.canFetchFull,
+  suggestedMode: rec10.suggestedMode,
+  suggestedItemsLimit: rec10.suggestedItemsLimit,
+  reason: rec10.reason,
+});
+
+// Follow recommendation
+const options: ExecutionFilterOptions = {
+  mode: rec10.suggestedMode,
+  itemsLimit: rec10.suggestedItemsLimit,
+};
+
+const recommendedResult = filterExecutionData(execution10, options);
+
+console.log('\n3. Following recommendation gives:', {
+  mode: recommendedResult.mode,
+  itemsShown: recommendedResult.nodes?.['HTTP Request']?.data?.metadata.itemsShown,
+  hasMoreData: recommendedResult.summary?.hasMoreData,
+});
+
+console.log('\n✅ Recommendation workflow helps make optimal choices\n');
+
+/**
+ * Summary
+ */
+console.log('='.repeat(80));
+console.log('✨ All Tests Completed Successfully!');
+console.log('='.repeat(80));
+console.log('\n🎉 Execution Filtering Feature is Working!\n');
+console.log('Key Takeaways:');
+console.log('1. Always use preview mode first for unknown datasets');
+console.log('2. Follow the recommendation for optimal token usage');
+console.log('3. Use nodeNames to filter to relevant nodes');
+console.log('4. itemsLimit: 0 shows structure without data');
+console.log('5. itemsLimit: -1 returns unlimited items (use with caution)');
+console.log('6. Summary mode (2 items) is a safe default');
+console.log('7. Full mode should only be used for small datasets');
+console.log('');

src/scripts/test-node-suggestions.ts

@@ -0,0 +1,205 @@
+#!/usr/bin/env npx tsx
+/**
+ * Test script for enhanced node type suggestions
+ * Tests the NodeSimilarityService to ensure it provides helpful suggestions
+ * for unknown or incorrectly typed nodes in workflows.
+ */
+
+import { createDatabaseAdapter } from '../database/database-adapter';
+import { NodeRepository } from '../database/node-repository';
+import { NodeSimilarityService } from '../services/node-similarity-service';
+import { WorkflowValidator } from '../services/workflow-validator';
+import { EnhancedConfigValidator } from '../services/enhanced-config-validator';
+import { WorkflowAutoFixer } from '../services/workflow-auto-fixer';
+import { Logger } from '../utils/logger';
+import path from 'path';
+
+const logger = new Logger({ prefix: '[NodeSuggestions Test]' });
+const console = {
+  log: (msg: string) => logger.info(msg),
+  error: (msg: string, err?: any) => logger.error(msg, err)
+};
+
+async function testNodeSimilarity() {
+  console.log('🔍 Testing Enhanced Node Type Suggestions\n');
+
+  // Initialize database and services
+  const dbPath = path.join(process.cwd(), 'data/nodes.db');
+  const db = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(db);
+  const similarityService = new NodeSimilarityService(repository);
+  const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+
+  // Test cases with various invalid node types
+  const testCases = [
+    // Case variations
+    { invalid: 'HttpRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'HTTPRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'Webhook', expected: 'nodes-base.webhook' },
+    { invalid: 'WebHook', expected: 'nodes-base.webhook' },
+
+    // Missing package prefix
+    { invalid: 'slack', expected: 'nodes-base.slack' },
+    { invalid: 'googleSheets', expected: 'nodes-base.googleSheets' },
+    { invalid: 'telegram', expected: 'nodes-base.telegram' },
+
+    // Common typos
+    { invalid: 'htpRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'webook', expected: 'nodes-base.webhook' },
+    { invalid: 'slak', expected: 'nodes-base.slack' },
+
+    // Partial names
+    { invalid: 'http', expected: 'nodes-base.httpRequest' },
+    { invalid: 'sheet', expected: 'nodes-base.googleSheets' },
+
+    // Wrong package prefix
+    { invalid: 'nodes-base.openai', expected: 'nodes-langchain.openAi' },
+    { invalid: 'n8n-nodes-base.httpRequest', expected: 'nodes-base.httpRequest' },
+
+    // Complete unknowns
+    { invalid: 'foobar', expected: null },
+    { invalid: 'xyz123', expected: null },
+  ];
+
+  console.log('Testing individual node type suggestions:');
+  console.log('=' .repeat(60));
+
+  for (const testCase of testCases) {
+    const suggestions = await similarityService.findSimilarNodes(testCase.invalid, 3);
+
+    console.log(`\n❌ Invalid type: "${testCase.invalid}"`);
+
+    if (suggestions.length > 0) {
+      console.log('✨ Suggestions:');
+      for (const suggestion of suggestions) {
+        const confidence = Math.round(suggestion.confidence * 100);
+        const marker = suggestion.nodeType === testCase.expected ? '✅' : '  ';
+        console.log(
+          `${marker} ${suggestion.nodeType} (${confidence}% match) - ${suggestion.reason}`
+        );
+
+        if (suggestion.confidence >= 0.9) {
+          console.log('   💡 Can be auto-fixed!');
+        }
+      }
+
+      // Check if expected match was found
+      if (testCase.expected) {
+        const found = suggestions.some(s => s.nodeType === testCase.expected);
+        if (!found) {
+          console.log(`   ⚠️  Expected "${testCase.expected}" was not suggested!`);
+        }
+      }
+    } else {
+      console.log('   No suggestions found');
+      if (testCase.expected) {
+        console.log(`   ⚠️  Expected "${testCase.expected}" was not suggested!`);
+      }
+    }
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log('\n📋 Testing workflow validation with unknown nodes:');
+  console.log('='.repeat(60));
+
+  // Test with a sample workflow
+  const testWorkflow = {
+    id: 'test-workflow',
+    name: 'Test Workflow',
+    nodes: [
+      {
+        id: '1',
+        name: 'Start',
+        type: 'nodes-base.manualTrigger',
+        position: [100, 100] as [number, number],
+        parameters: {},
+        typeVersion: 1
+      },
+      {
+        id: '2',
+        name: 'HTTP Request',
+        type: 'HTTPRequest', // Wrong capitalization
+        position: [300, 100] as [number, number],
+        parameters: {},
+        typeVersion: 1
+      },
+      {
+        id: '3',
+        name: 'Slack',
+        type: 'slack', // Missing prefix
+        position: [500, 100] as [number, number],
+        parameters: {},
+        typeVersion: 1
+      },
+      {
+        id: '4',
+        name: 'Unknown',
+        type: 'foobar', // Completely unknown
+        position: [700, 100] as [number, number],
+        parameters: {},
+        typeVersion: 1
+      }
+    ],
+    connections: {
+      'Start': {
+        main: [[{ node: 'HTTP Request', type: 'main', index: 0 }]]
+      },
+      'HTTP Request': {
+        main: [[{ node: 'Slack', type: 'main', index: 0 }]]
+      },
+      'Slack': {
+        main: [[{ node: 'Unknown', type: 'main', index: 0 }]]
+      }
+    },
+    settings: {}
+  };
+
+  const validationResult = await validator.validateWorkflow(testWorkflow as any, {
+    validateNodes: true,
+    validateConnections: false,
+    validateExpressions: false,
+    profile: 'runtime'
+  });
+
+  console.log('\nValidation Results:');
+  for (const error of validationResult.errors) {
+    if (error.message?.includes('Unknown node type:')) {
+      console.log(`\n🔴 ${error.nodeName}: ${error.message}`);
+    }
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log('\n🔧 Testing AutoFixer with node type corrections:');
+  console.log('='.repeat(60));
+
+  const autoFixer = new WorkflowAutoFixer(repository);
+  const fixResult = autoFixer.generateFixes(
+    testWorkflow as any,
+    validationResult,
+    [],
+    {
+      applyFixes: false,
+      fixTypes: ['node-type-correction'],
+      confidenceThreshold: 'high'
+    }
+  );
+
+  if (fixResult.fixes.length > 0) {
+    console.log('\n✅ Auto-fixable issues found:');
+    for (const fix of fixResult.fixes) {
+      console.log(`   • ${fix.description}`);
+    }
+    console.log(`\nSummary: ${fixResult.summary}`);
+  } else {
+    console.log('\n❌ No auto-fixable node type issues found (only high-confidence fixes are applied)');
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log('\n✨ Test complete!');
+}
+
+// Run the test
+testNodeSimilarity().catch(error => {
+  console.error('Test failed:', error);
+  process.exit(1);
+});

src/scripts/test-summary.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env npx tsx
+
+import { createDatabaseAdapter } from '../database/database-adapter';
+import { NodeRepository } from '../database/node-repository';
+import { NodeSimilarityService } from '../services/node-similarity-service';
+import path from 'path';
+
+async function testSummary() {
+  const dbPath = path.join(process.cwd(), 'data/nodes.db');
+  const db = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(db);
+  const similarityService = new NodeSimilarityService(repository);
+
+  const testCases = [
+    { invalid: 'HttpRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'HTTPRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'Webhook', expected: 'nodes-base.webhook' },
+    { invalid: 'WebHook', expected: 'nodes-base.webhook' },
+    { invalid: 'slack', expected: 'nodes-base.slack' },
+    { invalid: 'googleSheets', expected: 'nodes-base.googleSheets' },
+    { invalid: 'telegram', expected: 'nodes-base.telegram' },
+    { invalid: 'htpRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'webook', expected: 'nodes-base.webhook' },
+    { invalid: 'slak', expected: 'nodes-base.slack' },
+    { invalid: 'http', expected: 'nodes-base.httpRequest' },
+    { invalid: 'sheet', expected: 'nodes-base.googleSheets' },
+    { invalid: 'nodes-base.openai', expected: 'nodes-langchain.openAi' },
+    { invalid: 'n8n-nodes-base.httpRequest', expected: 'nodes-base.httpRequest' },
+    { invalid: 'foobar', expected: null },
+    { invalid: 'xyz123', expected: null },
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  console.log('Test Results Summary:');
+  console.log('='.repeat(60));
+
+  for (const testCase of testCases) {
+    const suggestions = await similarityService.findSimilarNodes(testCase.invalid, 3);
+
+    let result = '❌';
+    let status = 'FAILED';
+
+    if (testCase.expected === null) {
+      // Should have no suggestions
+      if (suggestions.length === 0) {
+        result = '✅';
+        status = 'PASSED';
+        passed++;
+      } else {
+        failed++;
+      }
+    } else {
+      // Should have the expected suggestion
+      const found = suggestions.some(s => s.nodeType === testCase.expected);
+      if (found) {
+        const suggestion = suggestions.find(s => s.nodeType === testCase.expected);
+        const isAutoFixable = suggestion && suggestion.confidence >= 0.9;
+        result = '✅';
+        status = isAutoFixable ? 'PASSED (auto-fixable)' : 'PASSED';
+        passed++;
+      } else {
+        failed++;
+      }
+    }
+
+    console.log(`${result} "${testCase.invalid}" → ${testCase.expected || 'no suggestions'}: ${status}`);
+  }
+
+  console.log('='.repeat(60));
+  console.log(`\nTotal: ${passed}/${testCases.length} tests passed`);
+
+  if (failed === 0) {
+    console.log('🎉 All tests passed!');
+  } else {
+    console.log(`⚠️  ${failed} tests failed`);
+  }
+}
+
+testSummary().catch(console.error);

src/scripts/test-webhook-autofix.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for webhook path autofixer functionality
+ */
+
+import { NodeRepository } from '../database/node-repository';
+import { createDatabaseAdapter } from '../database/database-adapter';
+import { WorkflowAutoFixer } from '../services/workflow-auto-fixer';
+import { WorkflowValidator } from '../services/workflow-validator';
+import { EnhancedConfigValidator } from '../services/enhanced-config-validator';
+import { Workflow } from '../types/n8n-api';
+import { Logger } from '../utils/logger';
+import { join } from 'path';
+
+const logger = new Logger({ prefix: '[TestWebhookAutofix]' });
+
+// Test workflow with webhook missing path
+const testWorkflow: Workflow = {
+  id: 'test_webhook_fix',
+  name: 'Test Webhook Autofix',
+  active: false,
+  nodes: [
+    {
+      id: '1',
+      name: 'Webhook',
+      type: 'n8n-nodes-base.webhook',
+      typeVersion: 2.1,
+      position: [250, 300],
+      parameters: {}, // Empty parameters - missing path
+    },
+    {
+      id: '2',
+      name: 'HTTP Request',
+      type: 'n8n-nodes-base.httpRequest',
+      typeVersion: 4.2,
+      position: [450, 300],
+      parameters: {
+        url: 'https://api.example.com/data',
+        method: 'GET'
+      }
+    }
+  ],
+  connections: {
+    'Webhook': {
+      main: [[{
+        node: 'HTTP Request',
+        type: 'main',
+        index: 0
+      }]]
+    }
+  },
+  settings: {
+    executionOrder: 'v1'
+  },
+  staticData: undefined
+};
+
+async function testWebhookAutofix() {
+  logger.info('Testing webhook path autofixer...');
+
+  // Initialize database and repository
+  const dbPath = join(process.cwd(), 'data', 'nodes.db');
+  const adapter = await createDatabaseAdapter(dbPath);
+  const repository = new NodeRepository(adapter);
+
+  // Create validators
+  const validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+  const autoFixer = new WorkflowAutoFixer(repository);
+
+  // Step 1: Validate workflow to identify issues
+  logger.info('Step 1: Validating workflow to identify issues...');
+  const validationResult = await validator.validateWorkflow(testWorkflow);
+
+  console.log('\n📋 Validation Summary:');
+  console.log(`- Valid: ${validationResult.valid}`);
+  console.log(`- Errors: ${validationResult.errors.length}`);
+  console.log(`- Warnings: ${validationResult.warnings.length}`);
+
+  if (validationResult.errors.length > 0) {
+    console.log('\n❌ Errors found:');
+    validationResult.errors.forEach(error => {
+      console.log(`  - [${error.nodeName || error.nodeId}] ${error.message}`);
+    });
+  }
+
+  // Step 2: Generate fixes (preview mode)
+  logger.info('\nStep 2: Generating fixes in preview mode...');
+
+  const fixResult = autoFixer.generateFixes(
+    testWorkflow,
+    validationResult,
+    [], // No expression format issues to pass
+    {
+      applyFixes: false, // Preview mode
+      fixTypes: ['webhook-missing-path'] // Only test webhook fixes
+    }
+  );
+
+  console.log('\n🔧 Fix Results:');
+  console.log(`- Summary: ${fixResult.summary}`);
+  console.log(`- Total fixes: ${fixResult.stats.total}`);
+  console.log(`- Webhook path fixes: ${fixResult.stats.byType['webhook-missing-path']}`);
+
+  if (fixResult.fixes.length > 0) {
+    console.log('\n📝 Detailed Fixes:');
+    fixResult.fixes.forEach(fix => {
+      console.log(`  - Node: ${fix.node}`);
+      console.log(`    Field: ${fix.field}`);
+      console.log(`    Type: ${fix.type}`);
+      console.log(`    Before: ${fix.before || 'undefined'}`);
+      console.log(`    After: ${fix.after}`);
+      console.log(`    Confidence: ${fix.confidence}`);
+      console.log(`    Description: ${fix.description}`);
+    });
+  }
+
+  if (fixResult.operations.length > 0) {
+    console.log('\n🔄 Operations to Apply:');
+    fixResult.operations.forEach(op => {
+      if (op.type === 'updateNode') {
+        console.log(`  - Update Node: ${op.nodeId}`);
+        console.log(`    Updates: ${JSON.stringify(op.updates, null, 2)}`);
+      }
+    });
+  }
+
+  // Step 3: Verify UUID format
+  if (fixResult.fixes.length > 0) {
+    const webhookFix = fixResult.fixes.find(f => f.type === 'webhook-missing-path');
+    if (webhookFix) {
+      const uuid = webhookFix.after as string;
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      const isValidUUID = uuidRegex.test(uuid);
+
+      console.log('\n✅ UUID Validation:');
+      console.log(`  - Generated UUID: ${uuid}`);
+      console.log(`  - Valid format: ${isValidUUID ? 'Yes' : 'No'}`);
+    }
+  }
+
+  logger.info('\n✨ Webhook autofix test completed successfully!');
+}
+
+// Run test
+testWebhookAutofix().catch(error => {
+  logger.error('Test failed:', error);
+  process.exit(1);
+});

src/services/config-validator.ts

@@ -19,7 +19,9 @@ export interface ValidationError {
   type: 'missing_required' | 'invalid_type' | 'invalid_value' | 'incompatible' | 'invalid_configuration' | 'syntax_error';
   property: string;
   message: string;
-  fix?: string;}
+  fix?: string;
+  suggestion?: string;
+}
 
 export interface ValidationWarning {
   type: 'missing_common' | 'deprecated' | 'inefficient' | 'security' | 'best_practice' | 'invalid_value';
@@ -106,16 +108,16 @@ export class ConfigValidator {
    * Check for missing required properties
    */
   private static checkRequiredProperties(
-    properties: any[], 
-    config: Record<string, any>, 
+    properties: any[],
+    config: Record<string, any>,
     errors: ValidationError[]
   ): void {
     for (const prop of properties) {
       if (!prop || !prop.name) continue; // Skip invalid properties
-      
+
       if (prop.required) {
         const value = config[prop.name];
-        
+
         // Check if property is missing or has null/undefined value
         if (!(prop.name in config)) {
           errors.push({
@@ -131,6 +133,14 @@ export class ConfigValidator {
             message: `Required property '${prop.displayName || prop.name}' cannot be null or undefined`,
             fix: `Provide a valid value for ${prop.name}`
           });
+        } else if (typeof value === 'string' && value.trim() === '') {
+          // Check for empty strings which are invalid for required string properties
+          errors.push({
+            type: 'missing_required',
+            property: prop.name,
+            message: `Required property '${prop.displayName || prop.name}' cannot be empty`,
+            fix: `Provide a valid value for ${prop.name}`
+          });
         }
       }
     }

src/services/enhanced-config-validator.ts

@@ -8,6 +8,11 @@
 import { ConfigValidator, ValidationResult, ValidationError, ValidationWarning } from './config-validator';
 import { NodeSpecificValidators, NodeValidationContext } from './node-specific-validators';
 import { FixedCollectionValidator } from '../utils/fixed-collection-validator';
+import { OperationSimilarityService } from './operation-similarity-service';
+import { ResourceSimilarityService } from './resource-similarity-service';
+import { NodeRepository } from '../database/node-repository';
+import { DatabaseAdapter } from '../database/database-adapter';
+import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
 
 export type ValidationMode = 'full' | 'operation' | 'minimal';
 export type ValidationProfile = 'strict' | 'runtime' | 'ai-friendly' | 'minimal';
@@ -35,6 +40,18 @@ export interface OperationContext {
 }
 
 export class EnhancedConfigValidator extends ConfigValidator {
+  private static operationSimilarityService: OperationSimilarityService | null = null;
+  private static resourceSimilarityService: ResourceSimilarityService | null = null;
+  private static nodeRepository: NodeRepository | null = null;
+
+  /**
+   * Initialize similarity services (called once at startup)
+   */
+  static initializeSimilarityServices(repository: NodeRepository): void {
+    this.nodeRepository = repository;
+    this.operationSimilarityService = new OperationSimilarityService(repository);
+    this.resourceSimilarityService = new ResourceSimilarityService(repository);
+  }
   /**
    * Validate with operation awareness
    */
@@ -60,17 +77,17 @@ export class EnhancedConfigValidator extends ConfigValidator {
     
     // Extract operation context from config
     const operationContext = this.extractOperationContext(config);
-    
-    // Filter properties based on mode and operation
-    const filteredProperties = this.filterPropertiesByMode(
+
+    // Filter properties based on mode and operation, and get config with defaults
+    const { properties: filteredProperties, configWithDefaults } = this.filterPropertiesByMode(
       properties,
       config,
       mode,
       operationContext
     );
-    
-    // Perform base validation on filtered properties
-    const baseResult = super.validate(nodeType, config, filteredProperties);
+
+    // Perform base validation on filtered properties with defaults applied
+    const baseResult = super.validate(nodeType, configWithDefaults, filteredProperties);
     
     // Enhance the result
     const enhancedResult: EnhancedValidationResult = {
@@ -120,31 +137,56 @@ export class EnhancedConfigValidator extends ConfigValidator {
   
   /**
    * Filter properties based on validation mode and operation
+   * Returns both filtered properties and config with defaults
    */
   private static filterPropertiesByMode(
     properties: any[],
     config: Record<string, any>,
     mode: ValidationMode,
     operation: OperationContext
-  ): any[] {
+  ): { properties: any[], configWithDefaults: Record<string, any> } {
+    // Apply defaults for visibility checking
+    const configWithDefaults = this.applyNodeDefaults(properties, config);
+
+    let filteredProperties: any[];
     switch (mode) {
       case 'minimal':
         // Only required properties that are visible
-        return properties.filter(prop => 
-          prop.required && this.isPropertyVisible(prop, config)
+        filteredProperties = properties.filter(prop =>
+          prop.required && this.isPropertyVisible(prop, configWithDefaults)
         );
-        
+        break;
+
       case 'operation':
         // Only properties relevant to the current operation
-        return properties.filter(prop => 
-          this.isPropertyRelevantToOperation(prop, config, operation)
+        filteredProperties = properties.filter(prop =>
+          this.isPropertyRelevantToOperation(prop, configWithDefaults, operation)
         );
-        
+        break;
+
       case 'full':
       default:
         // All properties (current behavior)
-        return properties;
+        filteredProperties = properties;
+        break;
     }
+
+    return { properties: filteredProperties, configWithDefaults };
+  }
+
+  /**
+   * Apply node defaults to configuration for accurate visibility checking
+   */
+  private static applyNodeDefaults(properties: any[], config: Record<string, any>): Record<string, any> {
+    const result = { ...config };
+
+    for (const prop of properties) {
+      if (prop.name && prop.default !== undefined && result[prop.name] === undefined) {
+        result[prop.name] = prop.default;
+      }
+    }
+
+    return result;
   }
   
   /**
@@ -213,7 +255,10 @@ export class EnhancedConfigValidator extends ConfigValidator {
       });
       return;
     }
-    
+
+    // Validate resource and operation using similarity services
+    this.validateResourceAndOperation(nodeType, config, result);
+
     // First, validate fixedCollection properties for known problematic nodes
     this.validateFixedCollectionStructures(nodeType, config, result);
     
@@ -642,4 +687,190 @@ export class EnhancedConfigValidator extends ConfigValidator {
     
     // Add any Filter-node-specific validation here in the future
   }
+
+  /**
+   * Validate resource and operation values using similarity services
+   */
+  private static validateResourceAndOperation(
+    nodeType: string,
+    config: Record<string, any>,
+    result: EnhancedValidationResult
+  ): void {
+    // Skip if similarity services not initialized
+    if (!this.operationSimilarityService || !this.resourceSimilarityService || !this.nodeRepository) {
+      return;
+    }
+
+    // Normalize the node type for repository lookups
+    const normalizedNodeType = NodeTypeNormalizer.normalizeToFullForm(nodeType);
+
+    // Apply defaults for validation
+    const configWithDefaults = { ...config };
+
+    // If operation is undefined but resource is set, get the default operation for that resource
+    if (configWithDefaults.operation === undefined && configWithDefaults.resource !== undefined) {
+      const defaultOperation = this.nodeRepository.getDefaultOperationForResource(normalizedNodeType, configWithDefaults.resource);
+      if (defaultOperation !== undefined) {
+        configWithDefaults.operation = defaultOperation;
+      }
+    }
+
+    // Validate resource field if present
+    if (config.resource !== undefined) {
+      // Remove any existing resource error from base validator to replace with our enhanced version
+      result.errors = result.errors.filter(e => e.property !== 'resource');
+      const validResources = this.nodeRepository.getNodeResources(normalizedNodeType);
+      const resourceIsValid = validResources.some(r => {
+        const resourceValue = typeof r === 'string' ? r : r.value;
+        return resourceValue === config.resource;
+      });
+
+      if (!resourceIsValid && config.resource !== '') {
+        // Find similar resources
+        let suggestions: any[] = [];
+        try {
+          suggestions = this.resourceSimilarityService.findSimilarResources(
+            normalizedNodeType,
+            config.resource,
+            3
+          );
+        } catch (error) {
+          // If similarity service fails, continue with validation without suggestions
+          console.error('Resource similarity service error:', error);
+        }
+
+        // Build error message with suggestions
+        let errorMessage = `Invalid resource "${config.resource}" for node ${nodeType}.`;
+        let fix = '';
+
+        if (suggestions.length > 0) {
+          const topSuggestion = suggestions[0];
+          // Always use "Did you mean" for the top suggestion
+          errorMessage += ` Did you mean "${topSuggestion.value}"?`;
+          if (topSuggestion.confidence >= 0.8) {
+            fix = `Change resource to "${topSuggestion.value}". ${topSuggestion.reason}`;
+          } else {
+            // For lower confidence, still show valid resources in the fix
+            fix = `Valid resources: ${validResources.slice(0, 5).map(r => {
+              const val = typeof r === 'string' ? r : r.value;
+              return `"${val}"`;
+            }).join(', ')}${validResources.length > 5 ? '...' : ''}`;
+          }
+        } else {
+          // No similar resources found, list valid ones
+          fix = `Valid resources: ${validResources.slice(0, 5).map(r => {
+            const val = typeof r === 'string' ? r : r.value;
+            return `"${val}"`;
+          }).join(', ')}${validResources.length > 5 ? '...' : ''}`;
+        }
+
+        const error: any = {
+          type: 'invalid_value',
+          property: 'resource',
+          message: errorMessage,
+          fix
+        };
+
+        // Add suggestion property if we have high confidence suggestions
+        if (suggestions.length > 0 && suggestions[0].confidence >= 0.5) {
+          error.suggestion = `Did you mean "${suggestions[0].value}"? ${suggestions[0].reason}`;
+        }
+
+        result.errors.push(error);
+
+        // Add suggestions to result.suggestions array
+        if (suggestions.length > 0) {
+          for (const suggestion of suggestions) {
+            result.suggestions.push(
+              `Resource "${config.resource}" not found. Did you mean "${suggestion.value}"? ${suggestion.reason}`
+            );
+          }
+        }
+      }
+    }
+
+    // Validate operation field - now we check configWithDefaults which has defaults applied
+    // Only validate if operation was explicitly set (not undefined) OR if we're using a default
+    if (config.operation !== undefined || configWithDefaults.operation !== undefined) {
+      // Remove any existing operation error from base validator to replace with our enhanced version
+      result.errors = result.errors.filter(e => e.property !== 'operation');
+
+      // Use the operation from configWithDefaults for validation (which includes the default if applied)
+      const operationToValidate = configWithDefaults.operation || config.operation;
+      const validOperations = this.nodeRepository.getNodeOperations(normalizedNodeType, config.resource);
+      const operationIsValid = validOperations.some(op => {
+        const opValue = op.operation || op.value || op;
+        return opValue === operationToValidate;
+      });
+
+      // Only report error if the explicit operation is invalid (not for defaults)
+      if (!operationIsValid && config.operation !== undefined && config.operation !== '') {
+        // Find similar operations
+        let suggestions: any[] = [];
+        try {
+          suggestions = this.operationSimilarityService.findSimilarOperations(
+            normalizedNodeType,
+            config.operation,
+            config.resource,
+            3
+          );
+        } catch (error) {
+          // If similarity service fails, continue with validation without suggestions
+          console.error('Operation similarity service error:', error);
+        }
+
+        // Build error message with suggestions
+        let errorMessage = `Invalid operation "${config.operation}" for node ${nodeType}`;
+        if (config.resource) {
+          errorMessage += ` with resource "${config.resource}"`;
+        }
+        errorMessage += '.';
+
+        let fix = '';
+
+        if (suggestions.length > 0) {
+          const topSuggestion = suggestions[0];
+          if (topSuggestion.confidence >= 0.8) {
+            errorMessage += ` Did you mean "${topSuggestion.value}"?`;
+            fix = `Change operation to "${topSuggestion.value}". ${topSuggestion.reason}`;
+          } else {
+            errorMessage += ` Similar operations: ${suggestions.map(s => `"${s.value}"`).join(', ')}`;
+            fix = `Valid operations${config.resource ? ` for resource "${config.resource}"` : ''}: ${validOperations.slice(0, 5).map(op => {
+              const val = op.operation || op.value || op;
+              return `"${val}"`;
+            }).join(', ')}${validOperations.length > 5 ? '...' : ''}`;
+          }
+        } else {
+          // No similar operations found, list valid ones
+          fix = `Valid operations${config.resource ? ` for resource "${config.resource}"` : ''}: ${validOperations.slice(0, 5).map(op => {
+            const val = op.operation || op.value || op;
+            return `"${val}"`;
+          }).join(', ')}${validOperations.length > 5 ? '...' : ''}`;
+        }
+
+        const error: any = {
+          type: 'invalid_value',
+          property: 'operation',
+          message: errorMessage,
+          fix
+        };
+
+        // Add suggestion property if we have high confidence suggestions
+        if (suggestions.length > 0 && suggestions[0].confidence >= 0.5) {
+          error.suggestion = `Did you mean "${suggestions[0].value}"? ${suggestions[0].reason}`;
+        }
+
+        result.errors.push(error);
+
+        // Add suggestions to result.suggestions array
+        if (suggestions.length > 0) {
+          for (const suggestion of suggestions) {
+            result.suggestions.push(
+              `Operation "${config.operation}" not found. Did you mean "${suggestion.value}"? ${suggestion.reason}`
+            );
+          }
+        }
+      }
+    }
+  }
 }

src/services/execution-processor.ts

@@ -0,0 +1,519 @@
+/**
+ * Execution Processor Service
+ *
+ * Intelligent processing and filtering of n8n execution data to enable
+ * AI agents to inspect executions without exceeding token limits.
+ *
+ * Features:
+ * - Preview mode: Show structure and counts without values
+ * - Summary mode: Smart default with 2 sample items per node
+ * - Filtered mode: Granular control (node filtering, item limits)
+ * - Smart recommendations: Guide optimal retrieval strategy
+ */
+
+import {
+  Execution,
+  ExecutionMode,
+  ExecutionPreview,
+  NodePreview,
+  ExecutionRecommendation,
+  ExecutionFilterOptions,
+  FilteredExecutionResponse,
+  FilteredNodeData,
+  ExecutionStatus,
+} from '../types/n8n-api';
+import { logger } from '../utils/logger';
+
+/**
+ * Size estimation and threshold constants
+ */
+const THRESHOLDS = {
+  CHAR_SIZE_BYTES: 2, // UTF-16 characters
+  OVERHEAD_PER_OBJECT: 50, // Approximate JSON overhead
+  MAX_RECOMMENDED_SIZE_KB: 100, // Threshold for "can fetch full"
+  SMALL_DATASET_ITEMS: 20, // <= this is considered small
+  MODERATE_DATASET_ITEMS: 50, // <= this is considered moderate
+  MODERATE_DATASET_SIZE_KB: 200, // <= this is considered moderate
+  MAX_DEPTH: 3, // Maximum depth for structure extraction
+  MAX_ITEMS_LIMIT: 1000, // Maximum allowed itemsLimit value
+} as const;
+
+/**
+ * Helper function to extract error message from various error formats
+ */
+function extractErrorMessage(error: unknown): string {
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error && typeof error === 'object') {
+    if ('message' in error && typeof error.message === 'string') {
+      return error.message;
+    }
+    if ('error' in error && typeof error.error === 'string') {
+      return error.error;
+    }
+  }
+  return 'Unknown error';
+}
+
+/**
+ * Extract data structure (JSON schema-like) from items
+ */
+function extractStructure(data: unknown, maxDepth = THRESHOLDS.MAX_DEPTH, currentDepth = 0): Record<string, unknown> | string | unknown[] {
+  if (currentDepth >= maxDepth) {
+    return typeof data;
+  }
+
+  if (data === null || data === undefined) {
+    return 'null';
+  }
+
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return [];
+    }
+    // Extract structure from first item
+    return [extractStructure(data[0], maxDepth, currentDepth + 1)];
+  }
+
+  if (typeof data === 'object') {
+    const structure: Record<string, unknown> = {};
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        structure[key] = extractStructure((data as Record<string, unknown>)[key], maxDepth, currentDepth + 1);
+      }
+    }
+    return structure;
+  }
+
+  return typeof data;
+}
+
+/**
+ * Estimate size of data in KB
+ */
+function estimateDataSize(data: unknown): number {
+  try {
+    const jsonString = JSON.stringify(data);
+    const sizeBytes = jsonString.length * THRESHOLDS.CHAR_SIZE_BYTES;
+    return Math.ceil(sizeBytes / 1024);
+  } catch (error) {
+    logger.warn('Failed to estimate data size', { error });
+    return 0;
+  }
+}
+
+/**
+ * Count items in execution data
+ */
+function countItems(nodeData: unknown): { input: number; output: number } {
+  const counts = { input: 0, output: 0 };
+
+  if (!nodeData || !Array.isArray(nodeData)) {
+    return counts;
+  }
+
+  for (const run of nodeData) {
+    if (run?.data?.main) {
+      const mainData = run.data.main;
+      if (Array.isArray(mainData)) {
+        for (const output of mainData) {
+          if (Array.isArray(output)) {
+            counts.output += output.length;
+          }
+        }
+      }
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Generate preview for an execution
+ */
+export function generatePreview(execution: Execution): {
+  preview: ExecutionPreview;
+  recommendation: ExecutionRecommendation;
+} {
+  const preview: ExecutionPreview = {
+    totalNodes: 0,
+    executedNodes: 0,
+    estimatedSizeKB: 0,
+    nodes: {},
+  };
+
+  if (!execution.data?.resultData?.runData) {
+    return {
+      preview,
+      recommendation: {
+        canFetchFull: true,
+        suggestedMode: 'summary',
+        reason: 'No execution data available',
+      },
+    };
+  }
+
+  const runData = execution.data.resultData.runData;
+  const nodeNames = Object.keys(runData);
+  preview.totalNodes = nodeNames.length;
+
+  let totalItemsOutput = 0;
+  let largestNodeItems = 0;
+
+  for (const nodeName of nodeNames) {
+    const nodeData = runData[nodeName];
+    const itemCounts = countItems(nodeData);
+
+    // Extract structure from first run's first output item
+    let dataStructure: Record<string, unknown> = {};
+    if (Array.isArray(nodeData) && nodeData.length > 0) {
+      const firstRun = nodeData[0];
+      const firstItem = firstRun?.data?.main?.[0]?.[0];
+      if (firstItem) {
+        dataStructure = extractStructure(firstItem) as Record<string, unknown>;
+      }
+    }
+
+    const nodeSize = estimateDataSize(nodeData);
+
+    const nodePreview: NodePreview = {
+      status: 'success',
+      itemCounts,
+      dataStructure,
+      estimatedSizeKB: nodeSize,
+    };
+
+    // Check for errors
+    if (Array.isArray(nodeData)) {
+      for (const run of nodeData) {
+        if (run.error) {
+          nodePreview.status = 'error';
+          nodePreview.error = extractErrorMessage(run.error);
+          break;
+        }
+      }
+    }
+
+    preview.nodes[nodeName] = nodePreview;
+    preview.estimatedSizeKB += nodeSize;
+    preview.executedNodes++;
+    totalItemsOutput += itemCounts.output;
+    largestNodeItems = Math.max(largestNodeItems, itemCounts.output);
+  }
+
+  // Generate recommendation
+  const recommendation = generateRecommendation(
+    preview.estimatedSizeKB,
+    totalItemsOutput,
+    largestNodeItems
+  );
+
+  return { preview, recommendation };
+}
+
+/**
+ * Generate smart recommendation based on data characteristics
+ */
+function generateRecommendation(
+  totalSizeKB: number,
+  totalItems: number,
+  largestNodeItems: number
+): ExecutionRecommendation {
+  // Can safely fetch full data
+  if (totalSizeKB <= THRESHOLDS.MAX_RECOMMENDED_SIZE_KB && totalItems <= THRESHOLDS.SMALL_DATASET_ITEMS) {
+    return {
+      canFetchFull: true,
+      suggestedMode: 'full',
+      reason: `Small dataset (${totalSizeKB}KB, ${totalItems} items). Safe to fetch full data.`,
+    };
+  }
+
+  // Moderate size - use summary
+  if (totalSizeKB <= THRESHOLDS.MODERATE_DATASET_SIZE_KB && totalItems <= THRESHOLDS.MODERATE_DATASET_ITEMS) {
+    return {
+      canFetchFull: false,
+      suggestedMode: 'summary',
+      suggestedItemsLimit: 2,
+      reason: `Moderate dataset (${totalSizeKB}KB, ${totalItems} items). Summary mode recommended.`,
+    };
+  }
+
+  // Large dataset - filter with limits
+  const suggestedLimit = Math.max(1, Math.min(5, Math.floor(100 / largestNodeItems)));
+
+  return {
+    canFetchFull: false,
+    suggestedMode: 'filtered',
+    suggestedItemsLimit: suggestedLimit,
+    reason: `Large dataset (${totalSizeKB}KB, ${totalItems} items). Use filtered mode with itemsLimit: ${suggestedLimit}.`,
+  };
+}
+
+/**
+ * Truncate items array with metadata
+ */
+function truncateItems(
+  items: unknown[][],
+  limit: number
+): {
+  truncated: unknown[][];
+  metadata: { totalItems: number; itemsShown: number; truncated: boolean };
+} {
+  if (!Array.isArray(items) || items.length === 0) {
+    return {
+      truncated: items || [],
+      metadata: {
+        totalItems: 0,
+        itemsShown: 0,
+        truncated: false,
+      },
+    };
+  }
+
+  let totalItems = 0;
+  for (const output of items) {
+    if (Array.isArray(output)) {
+      totalItems += output.length;
+    }
+  }
+
+  // Special case: limit = 0 means structure only
+  if (limit === 0) {
+    const structureOnly = items.map(output => {
+      if (!Array.isArray(output) || output.length === 0) {
+        return [];
+      }
+      return [extractStructure(output[0])];
+    });
+
+    return {
+      truncated: structureOnly,
+      metadata: {
+        totalItems,
+        itemsShown: 0,
+        truncated: true,
+      },
+    };
+  }
+
+  // Limit = -1 means unlimited
+  if (limit < 0) {
+    return {
+      truncated: items,
+      metadata: {
+        totalItems,
+        itemsShown: totalItems,
+        truncated: false,
+      },
+    };
+  }
+
+  // Apply limit
+  const result: unknown[][] = [];
+  let itemsShown = 0;
+
+  for (const output of items) {
+    if (!Array.isArray(output)) {
+      result.push(output);
+      continue;
+    }
+
+    if (itemsShown >= limit) {
+      break;
+    }
+
+    const remaining = limit - itemsShown;
+    const toTake = Math.min(remaining, output.length);
+    result.push(output.slice(0, toTake));
+    itemsShown += toTake;
+  }
+
+  return {
+    truncated: result,
+    metadata: {
+      totalItems,
+      itemsShown,
+      truncated: itemsShown < totalItems,
+    },
+  };
+}
+
+/**
+ * Filter execution data based on options
+ */
+export function filterExecutionData(
+  execution: Execution,
+  options: ExecutionFilterOptions
+): FilteredExecutionResponse {
+  const mode = options.mode || 'summary';
+
+  // Validate and bound itemsLimit
+  let itemsLimit = options.itemsLimit !== undefined ? options.itemsLimit : 2;
+  if (itemsLimit !== -1) { // -1 means unlimited
+    if (itemsLimit < 0) {
+      logger.warn('Invalid itemsLimit, defaulting to 2', { provided: itemsLimit });
+      itemsLimit = 2;
+    }
+    if (itemsLimit > THRESHOLDS.MAX_ITEMS_LIMIT) {
+      logger.warn(`itemsLimit capped at ${THRESHOLDS.MAX_ITEMS_LIMIT}`, { provided: itemsLimit });
+      itemsLimit = THRESHOLDS.MAX_ITEMS_LIMIT;
+    }
+  }
+
+  const includeInputData = options.includeInputData || false;
+  const nodeNamesFilter = options.nodeNames;
+
+  // Calculate duration
+  const duration = execution.stoppedAt && execution.startedAt
+    ? new Date(execution.stoppedAt).getTime() - new Date(execution.startedAt).getTime()
+    : undefined;
+
+  const response: FilteredExecutionResponse = {
+    id: execution.id,
+    workflowId: execution.workflowId,
+    status: execution.status,
+    mode,
+    startedAt: execution.startedAt,
+    stoppedAt: execution.stoppedAt,
+    duration,
+    finished: execution.finished,
+  };
+
+  // Handle preview mode
+  if (mode === 'preview') {
+    const { preview, recommendation } = generatePreview(execution);
+    response.preview = preview;
+    response.recommendation = recommendation;
+    return response;
+  }
+
+  // Handle no data case
+  if (!execution.data?.resultData?.runData) {
+    response.summary = {
+      totalNodes: 0,
+      executedNodes: 0,
+      totalItems: 0,
+      hasMoreData: false,
+    };
+    response.nodes = {};
+
+    if (execution.data?.resultData?.error) {
+      response.error = execution.data.resultData.error;
+    }
+
+    return response;
+  }
+
+  const runData = execution.data.resultData.runData;
+  let nodeNames = Object.keys(runData);
+
+  // Apply node name filter
+  if (nodeNamesFilter && nodeNamesFilter.length > 0) {
+    nodeNames = nodeNames.filter(name => nodeNamesFilter.includes(name));
+  }
+
+  // Process nodes
+  const processedNodes: Record<string, FilteredNodeData> = {};
+  let totalItems = 0;
+  let hasMoreData = false;
+
+  for (const nodeName of nodeNames) {
+    const nodeData = runData[nodeName];
+
+    if (!Array.isArray(nodeData) || nodeData.length === 0) {
+      processedNodes[nodeName] = {
+        itemsInput: 0,
+        itemsOutput: 0,
+        status: 'success',
+      };
+      continue;
+    }
+
+    // Get first run data
+    const firstRun = nodeData[0];
+    const itemCounts = countItems(nodeData);
+    totalItems += itemCounts.output;
+
+    const nodeResult: FilteredNodeData = {
+      executionTime: firstRun.executionTime,
+      itemsInput: itemCounts.input,
+      itemsOutput: itemCounts.output,
+      status: 'success',
+    };
+
+    // Check for errors
+    if (firstRun.error) {
+      nodeResult.status = 'error';
+      nodeResult.error = extractErrorMessage(firstRun.error);
+    }
+
+    // Handle full mode - include all data
+    if (mode === 'full') {
+      nodeResult.data = {
+        output: firstRun.data?.main || [],
+        metadata: {
+          totalItems: itemCounts.output,
+          itemsShown: itemCounts.output,
+          truncated: false,
+        },
+      };
+
+      if (includeInputData && firstRun.inputData) {
+        nodeResult.data.input = firstRun.inputData;
+      }
+    } else {
+      // Summary or filtered mode - apply limits
+      const outputData = firstRun.data?.main || [];
+      const { truncated, metadata } = truncateItems(outputData, itemsLimit);
+
+      if (metadata.truncated) {
+        hasMoreData = true;
+      }
+
+      nodeResult.data = {
+        output: truncated,
+        metadata,
+      };
+
+      if (includeInputData && firstRun.inputData) {
+        nodeResult.data.input = firstRun.inputData;
+      }
+    }
+
+    processedNodes[nodeName] = nodeResult;
+  }
+
+  // Add summary
+  response.summary = {
+    totalNodes: Object.keys(runData).length,
+    executedNodes: nodeNames.length,
+    totalItems,
+    hasMoreData,
+  };
+
+  response.nodes = processedNodes;
+
+  // Include error if present
+  if (execution.data?.resultData?.error) {
+    response.error = execution.data.resultData.error;
+  }
+
+  return response;
+}
+
+/**
+ * Process execution based on mode and options
+ * Main entry point for the service
+ */
+export function processExecution(
+  execution: Execution,
+  options: ExecutionFilterOptions = {}
+): FilteredExecutionResponse | Execution {
+  // Legacy behavior: if no mode specified and no filtering options, return original
+  if (!options.mode && !options.nodeNames && options.itemsLimit === undefined) {
+    return execution;
+  }
+
+  return filterExecutionData(execution, options);
+}

src/services/expression-validator.ts

@@ -141,12 +141,21 @@ export class ExpressionValidator {
     const jsonPattern = new RegExp(this.VARIABLE_PATTERNS.json.source, this.VARIABLE_PATTERNS.json.flags);
     while ((match = jsonPattern.exec(expr)) !== null) {
       result.usedVariables.add('$json');
-      
+
       if (!context.hasInputData && !context.isInLoop) {
         result.warnings.push(
           'Using $json but node might not have input data'
         );
       }
+
+      // Check for suspicious property names that might be test/invalid data
+      const fullMatch = match[0];
+      if (fullMatch.includes('.invalid') || fullMatch.includes('.undefined') ||
+          fullMatch.includes('.null') || fullMatch.includes('.test')) {
+        result.warnings.push(
+          `Property access '${fullMatch}' looks suspicious - verify this property exists in your data`
+        );
+      }
     }
 
     // Check for $node references

src/services/n8n-api-client.ts

@@ -161,9 +161,10 @@ export class N8nApiClient {
     }
   }
 
-  async deleteWorkflow(id: string): Promise<void> {
+  async deleteWorkflow(id: string): Promise<Workflow> {
     try {
-      await this.client.delete(`/workflows/${id}`);
+      const response = await this.client.delete(`/workflows/${id}`);
+      return response.data;
     } catch (error) {
       throw handleN8nApiError(error);
     }

src/services/n8n-validation.ts

@@ -45,6 +45,7 @@ export const workflowSettingsSchema = z.object({
   saveExecutionProgress: z.boolean().default(true),
   executionTimeout: z.number().optional(),
   errorWorkflow: z.string().optional(),
+  callerPolicy: z.enum(['any', 'workflowsFromSameOwner', 'workflowsFromAList']).optional(),
 });
 
 // Default settings for workflow creation
@@ -95,14 +96,17 @@ export function cleanWorkflowForCreate(workflow: Partial<Workflow>): Partial<Wor
 
 /**
  * Clean workflow data for update operations.
- * 
+ *
  * This function removes read-only and computed fields that should not be sent
  * in API update requests. It does NOT add any default values or new fields.
- * 
+ *
  * Note: Unlike cleanWorkflowForCreate, this function does not add default settings.
  * The n8n API will reject update requests that include properties not present in
  * the original workflow ("settings must NOT have additional properties" error).
- * 
+ *
+ * Settings are filtered to only include whitelisted properties to prevent API
+ * errors when workflows from n8n contain UI-only or deprecated properties.
+ *
  * @param workflow - The workflow object to clean
  * @returns A cleaned partial workflow suitable for API updates
  */
@@ -129,6 +133,51 @@ export function cleanWorkflowForUpdate(workflow: Workflow): Partial<Workflow> {
     ...cleanedWorkflow
   } = workflow as any;
 
+  // CRITICAL FIX for Issue #248:
+  // The n8n API has version-specific behavior for settings in workflow updates:
+  //
+  // PROBLEM:
+  // - Some versions reject updates with settings properties (community forum reports)
+  // - Cloud versions REQUIRE settings property to be present (n8n.estyl.team)
+  // - Properties like callerPolicy cause "additional properties" errors
+  //
+  // SOLUTION:
+  // - Filter settings to only include whitelisted properties (OpenAPI spec)
+  // - If no settings provided, use empty object {} for safety
+  // - Empty object satisfies "required property" validation (cloud API)
+  // - Whitelisted properties prevent "additional properties" errors
+  //
+  // References:
+  // - https://community.n8n.io/t/api-workflow-update-endpoint-doesnt-support-setting-callerpolicy/161916
+  // - OpenAPI spec: workflowSettings schema
+  // - Tested on n8n.estyl.team (cloud) and localhost (self-hosted)
+
+  // Whitelisted settings properties from n8n OpenAPI spec
+  const safeSettingsProperties = [
+    'saveExecutionProgress',
+    'saveManualExecutions',
+    'saveDataErrorExecution',
+    'saveDataSuccessExecution',
+    'executionTimeout',
+    'errorWorkflow',
+    'timezone',
+    'executionOrder'
+  ];
+
+  if (cleanedWorkflow.settings && typeof cleanedWorkflow.settings === 'object') {
+    // Filter to only safe properties
+    const filteredSettings: any = {};
+    for (const key of safeSettingsProperties) {
+      if (key in cleanedWorkflow.settings) {
+        filteredSettings[key] = (cleanedWorkflow.settings as any)[key];
+      }
+    }
+    cleanedWorkflow.settings = filteredSettings;
+  } else {
+    // No settings provided - use empty object for safety
+    cleanedWorkflow.settings = {};
+  }
+
   return cleanedWorkflow;
 }
 

src/services/node-similarity-service.ts

@@ -0,0 +1,512 @@
+import { NodeRepository } from '../database/node-repository';
+import { logger } from '../utils/logger';
+
+export interface NodeSuggestion {
+  nodeType: string;
+  displayName: string;
+  confidence: number;
+  reason: string;
+  category?: string;
+  description?: string;
+}
+
+export interface SimilarityScore {
+  nameSimilarity: number;
+  categoryMatch: number;
+  packageMatch: number;
+  patternMatch: number;
+  totalScore: number;
+}
+
+export interface CommonMistakePattern {
+  pattern: string;
+  suggestion: string;
+  confidence: number;
+  reason: string;
+}
+
+export class NodeSimilarityService {
+  // Constants to avoid magic numbers
+  private static readonly SCORING_THRESHOLD = 50; // Minimum 50% confidence to suggest
+  private static readonly TYPO_EDIT_DISTANCE = 2; // Max 2 character differences for typo detection
+  private static readonly SHORT_SEARCH_LENGTH = 5; // Searches ≤5 chars need special handling
+  private static readonly CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+  private static readonly AUTO_FIX_CONFIDENCE = 0.9; // 90% confidence for auto-fix
+
+  private repository: NodeRepository;
+  private commonMistakes: Map<string, CommonMistakePattern[]>;
+  private nodeCache: any[] | null = null;
+  private cacheExpiry: number = 0;
+  private cacheVersion: number = 0; // Track cache version for invalidation
+
+  constructor(repository: NodeRepository) {
+    this.repository = repository;
+    this.commonMistakes = this.initializeCommonMistakes();
+  }
+
+  /**
+   * Initialize common mistake patterns
+   * Using safer string-based patterns instead of complex regex to avoid ReDoS
+   */
+  private initializeCommonMistakes(): Map<string, CommonMistakePattern[]> {
+    const patterns = new Map<string, CommonMistakePattern[]>();
+
+    // Case variations - using exact string matching (case-insensitive)
+    patterns.set('case_variations', [
+      { pattern: 'httprequest', suggestion: 'nodes-base.httpRequest', confidence: 0.95, reason: 'Incorrect capitalization' },
+      { pattern: 'webhook', suggestion: 'nodes-base.webhook', confidence: 0.95, reason: 'Incorrect capitalization' },
+      { pattern: 'slack', suggestion: 'nodes-base.slack', confidence: 0.9, reason: 'Missing package prefix' },
+      { pattern: 'gmail', suggestion: 'nodes-base.gmail', confidence: 0.9, reason: 'Missing package prefix' },
+      { pattern: 'googlesheets', suggestion: 'nodes-base.googleSheets', confidence: 0.9, reason: 'Missing package prefix' },
+      { pattern: 'telegram', suggestion: 'nodes-base.telegram', confidence: 0.9, reason: 'Missing package prefix' },
+    ]);
+
+    // Specific case variations that are common
+    patterns.set('specific_variations', [
+      { pattern: 'HttpRequest', suggestion: 'nodes-base.httpRequest', confidence: 0.95, reason: 'Incorrect capitalization' },
+      { pattern: 'HTTPRequest', suggestion: 'nodes-base.httpRequest', confidence: 0.95, reason: 'Common capitalization mistake' },
+      { pattern: 'Webhook', suggestion: 'nodes-base.webhook', confidence: 0.95, reason: 'Incorrect capitalization' },
+      { pattern: 'WebHook', suggestion: 'nodes-base.webhook', confidence: 0.95, reason: 'Common capitalization mistake' },
+    ]);
+
+    // Deprecated package prefixes
+    patterns.set('deprecated_prefixes', [
+      { pattern: 'n8n-nodes-base.', suggestion: 'nodes-base.', confidence: 0.95, reason: 'Full package name used instead of short form' },
+      { pattern: '@n8n/n8n-nodes-langchain.', suggestion: 'nodes-langchain.', confidence: 0.95, reason: 'Full package name used instead of short form' },
+    ]);
+
+    // Common typos - exact matches
+    patterns.set('typos', [
+      { pattern: 'htprequest', suggestion: 'nodes-base.httpRequest', confidence: 0.8, reason: 'Likely typo' },
+      { pattern: 'httpreqest', suggestion: 'nodes-base.httpRequest', confidence: 0.8, reason: 'Likely typo' },
+      { pattern: 'webook', suggestion: 'nodes-base.webhook', confidence: 0.8, reason: 'Likely typo' },
+      { pattern: 'slak', suggestion: 'nodes-base.slack', confidence: 0.8, reason: 'Likely typo' },
+      { pattern: 'googlesheets', suggestion: 'nodes-base.googleSheets', confidence: 0.8, reason: 'Likely typo' },
+    ]);
+
+    // AI/LangChain specific
+    patterns.set('ai_nodes', [
+      { pattern: 'openai', suggestion: 'nodes-langchain.openAi', confidence: 0.85, reason: 'AI node - incorrect package' },
+      { pattern: 'nodes-base.openai', suggestion: 'nodes-langchain.openAi', confidence: 0.9, reason: 'Wrong package - OpenAI is in LangChain package' },
+      { pattern: 'chatopenai', suggestion: 'nodes-langchain.lmChatOpenAi', confidence: 0.85, reason: 'LangChain node naming convention' },
+      { pattern: 'vectorstore', suggestion: 'nodes-langchain.vectorStoreInMemory', confidence: 0.7, reason: 'Generic vector store reference' },
+    ]);
+
+    return patterns;
+  }
+
+  /**
+   * Check if a type is a common node name without prefix
+   */
+  private isCommonNodeWithoutPrefix(type: string): string | null {
+    const commonNodes: Record<string, string> = {
+      'httprequest': 'nodes-base.httpRequest',
+      'webhook': 'nodes-base.webhook',
+      'slack': 'nodes-base.slack',
+      'gmail': 'nodes-base.gmail',
+      'googlesheets': 'nodes-base.googleSheets',
+      'telegram': 'nodes-base.telegram',
+      'discord': 'nodes-base.discord',
+      'notion': 'nodes-base.notion',
+      'airtable': 'nodes-base.airtable',
+      'postgres': 'nodes-base.postgres',
+      'mysql': 'nodes-base.mySql',
+      'mongodb': 'nodes-base.mongoDb',
+    };
+
+    const normalized = type.toLowerCase();
+    return commonNodes[normalized] || null;
+  }
+
+  /**
+   * Find similar nodes for an invalid type
+   */
+  async findSimilarNodes(invalidType: string, limit: number = 5): Promise<NodeSuggestion[]> {
+    if (!invalidType || invalidType.trim() === '') {
+      return [];
+    }
+
+    const suggestions: NodeSuggestion[] = [];
+
+    // First, check for exact common mistakes
+    const mistakeSuggestion = this.checkCommonMistakes(invalidType);
+    if (mistakeSuggestion) {
+      suggestions.push(mistakeSuggestion);
+    }
+
+    // Get all nodes (with caching)
+    const allNodes = await this.getCachedNodes();
+
+    // Calculate similarity scores for all nodes
+    const scores = allNodes.map(node => ({
+      node,
+      score: this.calculateSimilarityScore(invalidType, node)
+    }));
+
+    // Sort by total score and filter high scores
+    scores.sort((a, b) => b.score.totalScore - a.score.totalScore);
+
+    // Add top suggestions (excluding already added exact matches)
+    for (const { node, score } of scores) {
+      if (suggestions.some(s => s.nodeType === node.nodeType)) {
+        continue;
+      }
+
+      if (score.totalScore >= NodeSimilarityService.SCORING_THRESHOLD) {
+        suggestions.push(this.createSuggestion(node, score));
+      }
+
+      if (suggestions.length >= limit) {
+        break;
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Check for common mistake patterns (ReDoS-safe implementation)
+   */
+  private checkCommonMistakes(invalidType: string): NodeSuggestion | null {
+    const cleanType = invalidType.trim();
+    const lowerType = cleanType.toLowerCase();
+
+    // First check for common nodes without prefix
+    const commonNodeSuggestion = this.isCommonNodeWithoutPrefix(cleanType);
+    if (commonNodeSuggestion) {
+      const node = this.repository.getNode(commonNodeSuggestion);
+      if (node) {
+        return {
+          nodeType: commonNodeSuggestion,
+          displayName: node.displayName,
+          confidence: 0.9,
+          reason: 'Missing package prefix',
+          category: node.category,
+          description: node.description
+        };
+      }
+    }
+
+    // Check deprecated prefixes (string-based, no regex)
+    for (const [category, patterns] of this.commonMistakes) {
+      if (category === 'deprecated_prefixes') {
+        for (const pattern of patterns) {
+          if (cleanType.startsWith(pattern.pattern)) {
+            const actualSuggestion = cleanType.replace(pattern.pattern, pattern.suggestion);
+            const node = this.repository.getNode(actualSuggestion);
+            if (node) {
+              return {
+                nodeType: actualSuggestion,
+                displayName: node.displayName,
+                confidence: pattern.confidence,
+                reason: pattern.reason,
+                category: node.category,
+                description: node.description
+              };
+            }
+          }
+        }
+      }
+    }
+
+    // Check exact matches for typos and variations
+    for (const [category, patterns] of this.commonMistakes) {
+      if (category === 'deprecated_prefixes') continue; // Already handled
+
+      for (const pattern of patterns) {
+        // Simple string comparison (case-sensitive for specific_variations)
+        const match = category === 'specific_variations'
+          ? cleanType === pattern.pattern
+          : lowerType === pattern.pattern.toLowerCase();
+
+        if (match && pattern.suggestion) {
+          const node = this.repository.getNode(pattern.suggestion);
+          if (node) {
+            return {
+              nodeType: pattern.suggestion,
+              displayName: node.displayName,
+              confidence: pattern.confidence,
+              reason: pattern.reason,
+              category: node.category,
+              description: node.description
+            };
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Calculate multi-factor similarity score
+   */
+  private calculateSimilarityScore(invalidType: string, node: any): SimilarityScore {
+    const cleanInvalid = this.normalizeNodeType(invalidType);
+    const cleanValid = this.normalizeNodeType(node.nodeType);
+    const displayNameClean = this.normalizeNodeType(node.displayName);
+
+    // Special handling for very short search terms (e.g., "http", "sheet")
+    const isShortSearch = invalidType.length <= NodeSimilarityService.SHORT_SEARCH_LENGTH;
+
+    // Name similarity (40% weight)
+    let nameSimilarity = Math.max(
+      this.getStringSimilarity(cleanInvalid, cleanValid),
+      this.getStringSimilarity(cleanInvalid, displayNameClean)
+    ) * 40;
+
+    // For short searches that are substrings, give a small name similarity boost
+    if (isShortSearch && (cleanValid.includes(cleanInvalid) || displayNameClean.includes(cleanInvalid))) {
+      nameSimilarity = Math.max(nameSimilarity, 10);
+    }
+
+    // Category match (20% weight)
+    let categoryMatch = 0;
+    if (node.category) {
+      const categoryClean = this.normalizeNodeType(node.category);
+      if (cleanInvalid.includes(categoryClean) || categoryClean.includes(cleanInvalid)) {
+        categoryMatch = 20;
+      }
+    }
+
+    // Package match (15% weight)
+    let packageMatch = 0;
+    const invalidParts = cleanInvalid.split(/[.-]/);
+    const validParts = cleanValid.split(/[.-]/);
+
+    if (invalidParts[0] === validParts[0]) {
+      packageMatch = 15;
+    }
+
+    // Pattern match (25% weight)
+    let patternMatch = 0;
+
+    // Check if it's a substring match
+    if (cleanValid.includes(cleanInvalid) || displayNameClean.includes(cleanInvalid)) {
+      // Boost score significantly for short searches that are exact substring matches
+      // Short searches need more boost to reach the 50 threshold
+      patternMatch = isShortSearch ? 45 : 25;
+    } else if (this.getEditDistance(cleanInvalid, cleanValid) <= NodeSimilarityService.TYPO_EDIT_DISTANCE) {
+      // Small edit distance indicates likely typo
+      patternMatch = 20;
+    } else if (this.getEditDistance(cleanInvalid, displayNameClean) <= NodeSimilarityService.TYPO_EDIT_DISTANCE) {
+      patternMatch = 18;
+    }
+
+    // For very short searches, also check if the search term appears at the start
+    if (isShortSearch && (cleanValid.startsWith(cleanInvalid) || displayNameClean.startsWith(cleanInvalid))) {
+      patternMatch = Math.max(patternMatch, 40);
+    }
+
+    const totalScore = nameSimilarity + categoryMatch + packageMatch + patternMatch;
+
+    return {
+      nameSimilarity,
+      categoryMatch,
+      packageMatch,
+      patternMatch,
+      totalScore
+    };
+  }
+
+  /**
+   * Create a suggestion object from node and score
+   */
+  private createSuggestion(node: any, score: SimilarityScore): NodeSuggestion {
+    let reason = 'Similar node';
+
+    if (score.patternMatch >= 20) {
+      reason = 'Name similarity';
+    } else if (score.categoryMatch >= 15) {
+      reason = 'Same category';
+    } else if (score.packageMatch >= 10) {
+      reason = 'Same package';
+    }
+
+    // Calculate confidence (0-1 scale)
+    const confidence = Math.min(score.totalScore / 100, 1);
+
+    return {
+      nodeType: node.nodeType,
+      displayName: node.displayName,
+      confidence,
+      reason,
+      category: node.category,
+      description: node.description
+    };
+  }
+
+  /**
+   * Normalize node type for comparison
+   */
+  private normalizeNodeType(type: string): string {
+    return type
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '')
+      .trim();
+  }
+
+  /**
+   * Calculate string similarity (0-1)
+   */
+  private getStringSimilarity(s1: string, s2: string): number {
+    if (s1 === s2) return 1;
+    if (!s1 || !s2) return 0;
+
+    const distance = this.getEditDistance(s1, s2);
+    const maxLen = Math.max(s1.length, s2.length);
+
+    return 1 - (distance / maxLen);
+  }
+
+  /**
+   * Calculate Levenshtein distance with optimizations
+   * - Early termination when difference exceeds threshold
+   * - Space-optimized to use only two rows instead of full matrix
+   * - Fast path for identical or vastly different strings
+   */
+  private getEditDistance(s1: string, s2: string, maxDistance: number = 5): number {
+    // Fast path: identical strings
+    if (s1 === s2) return 0;
+
+    const m = s1.length;
+    const n = s2.length;
+
+    // Fast path: length difference exceeds threshold
+    const lengthDiff = Math.abs(m - n);
+    if (lengthDiff > maxDistance) return maxDistance + 1;
+
+    // Fast path: empty strings
+    if (m === 0) return n;
+    if (n === 0) return m;
+
+    // Space optimization: only need previous and current row
+    let prev = Array(n + 1).fill(0).map((_, i) => i);
+
+    for (let i = 1; i <= m; i++) {
+      const curr = [i];
+      let minInRow = i;
+
+      for (let j = 1; j <= n; j++) {
+        const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+        const val = Math.min(
+          curr[j - 1] + 1,      // deletion
+          prev[j] + 1,          // insertion
+          prev[j - 1] + cost    // substitution
+        );
+        curr.push(val);
+        minInRow = Math.min(minInRow, val);
+      }
+
+      // Early termination: if minimum in this row exceeds threshold
+      if (minInRow > maxDistance) {
+        return maxDistance + 1;
+      }
+
+      prev = curr;
+    }
+
+    return prev[n];
+  }
+
+  /**
+   * Get cached nodes or fetch from repository
+   * Implements proper cache invalidation with version tracking
+   */
+  private async getCachedNodes(): Promise<any[]> {
+    const now = Date.now();
+
+    if (!this.nodeCache || now > this.cacheExpiry) {
+      try {
+        const newNodes = this.repository.getAllNodes();
+
+        // Only update cache if we got valid data
+        if (newNodes && newNodes.length > 0) {
+          this.nodeCache = newNodes;
+          this.cacheExpiry = now + NodeSimilarityService.CACHE_DURATION_MS;
+          this.cacheVersion++;
+          logger.debug('Node cache refreshed', {
+            count: newNodes.length,
+            version: this.cacheVersion
+          });
+        } else if (this.nodeCache) {
+          // Return stale cache if new fetch returned empty
+          logger.warn('Node fetch returned empty, using stale cache');
+        }
+      } catch (error) {
+        logger.error('Failed to fetch nodes for similarity service', error);
+        // Return stale cache on error if available
+        if (this.nodeCache) {
+          logger.info('Using stale cache due to fetch error');
+          return this.nodeCache;
+        }
+        return [];
+      }
+    }
+
+    return this.nodeCache || [];
+  }
+
+  /**
+   * Invalidate the cache (e.g., after database updates)
+   */
+  public invalidateCache(): void {
+    this.nodeCache = null;
+    this.cacheExpiry = 0;
+    this.cacheVersion++;
+    logger.debug('Node cache invalidated', { version: this.cacheVersion });
+  }
+
+  /**
+   * Clear and refresh cache immediately
+   */
+  public async refreshCache(): Promise<void> {
+    this.invalidateCache();
+    await this.getCachedNodes();
+  }
+
+  /**
+   * Format suggestions into a user-friendly message
+   */
+  formatSuggestionMessage(suggestions: NodeSuggestion[], invalidType: string): string {
+    if (suggestions.length === 0) {
+      return `Unknown node type: "${invalidType}". No similar nodes found.`;
+    }
+
+    let message = `Unknown node type: "${invalidType}"\n\nDid you mean one of these?\n`;
+
+    for (const suggestion of suggestions) {
+      const confidence = Math.round(suggestion.confidence * 100);
+      message += `• ${suggestion.nodeType} (${confidence}% match)`;
+
+      if (suggestion.displayName) {
+        message += ` - ${suggestion.displayName}`;
+      }
+
+      message += `\n  → ${suggestion.reason}`;
+
+      if (suggestion.confidence >= 0.9) {
+        message += ' (can be auto-fixed)';
+      }
+
+      message += '\n';
+    }
+
+    return message;
+  }
+
+  /**
+   * Check if a suggestion is high confidence for auto-fixing
+   */
+  isAutoFixable(suggestion: NodeSuggestion): boolean {
+    return suggestion.confidence >= NodeSimilarityService.AUTO_FIX_CONFIDENCE;
+  }
+
+  /**
+   * Clear the node cache (useful after database updates)
+   * @deprecated Use invalidateCache() instead for proper version tracking
+   */
+  clearCache(): void {
+    this.invalidateCache();
+  }
+}

src/services/node-specific-validators.ts

@@ -1132,8 +1132,11 @@ export class NodeSpecificValidators {
     const syntaxPatterns = [
       { pattern: /const\s+const/, message: 'Duplicate const declaration' },
       { pattern: /let\s+let/, message: 'Duplicate let declaration' },
-      { pattern: /\)\s*\)\s*{/, message: 'Extra closing parenthesis before {' },
-      { pattern: /}\s*}$/, message: 'Extra closing brace at end' }
+      // Removed overly simplistic parenthesis check - it was causing false positives
+      // for valid patterns like $('NodeName').first().json or func()()
+      // { pattern: /\)\s*\)\s*{/, message: 'Extra closing parenthesis before {' },
+      // Only check for multiple closing braces at the very end (more likely to be an error)
+      { pattern: /}\s*}\s*}\s*}$/, message: 'Multiple closing braces at end - check your nesting' }
     ];
     
     syntaxPatterns.forEach(({ pattern, message }) => {

src/services/operation-similarity-service.ts

@@ -0,0 +1,502 @@
+import { NodeRepository } from '../database/node-repository';
+import { logger } from '../utils/logger';
+import { ValidationServiceError } from '../errors/validation-service-error';
+
+export interface OperationSuggestion {
+  value: string;
+  confidence: number;
+  reason: string;
+  resource?: string;
+  description?: string;
+}
+
+interface OperationPattern {
+  pattern: string;
+  suggestion: string;
+  confidence: number;
+  reason: string;
+}
+
+export class OperationSimilarityService {
+  private static readonly CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+  private static readonly MIN_CONFIDENCE = 0.3; // 30% minimum confidence to suggest
+  private static readonly MAX_SUGGESTIONS = 5;
+
+  // Confidence thresholds for better code clarity
+  private static readonly CONFIDENCE_THRESHOLDS = {
+    EXACT: 1.0,
+    VERY_HIGH: 0.95,
+    HIGH: 0.8,
+    MEDIUM: 0.6,
+    MIN_SUBSTRING: 0.7
+  } as const;
+
+  private repository: NodeRepository;
+  private operationCache: Map<string, { operations: any[], timestamp: number }> = new Map();
+  private suggestionCache: Map<string, OperationSuggestion[]> = new Map();
+  private commonPatterns: Map<string, OperationPattern[]>;
+
+  constructor(repository: NodeRepository) {
+    this.repository = repository;
+    this.commonPatterns = this.initializeCommonPatterns();
+  }
+
+  /**
+   * Clean up expired cache entries to prevent memory leaks
+   * Should be called periodically or before cache operations
+   */
+  private cleanupExpiredEntries(): void {
+    const now = Date.now();
+
+    // Clean operation cache
+    for (const [key, value] of this.operationCache.entries()) {
+      if (now - value.timestamp >= OperationSimilarityService.CACHE_DURATION_MS) {
+        this.operationCache.delete(key);
+      }
+    }
+
+    // Clean suggestion cache - these don't have timestamps, so clear if cache is too large
+    if (this.suggestionCache.size > 100) {
+      // Keep only the most recent 50 entries
+      const entries = Array.from(this.suggestionCache.entries());
+      this.suggestionCache.clear();
+      entries.slice(-50).forEach(([key, value]) => {
+        this.suggestionCache.set(key, value);
+      });
+    }
+  }
+
+  /**
+   * Initialize common operation mistake patterns
+   */
+  private initializeCommonPatterns(): Map<string, OperationPattern[]> {
+    const patterns = new Map<string, OperationPattern[]>();
+
+    // Google Drive patterns
+    patterns.set('googleDrive', [
+      { pattern: 'listFiles', suggestion: 'search', confidence: 0.85, reason: 'Use "search" with resource: "fileFolder" to list files' },
+      { pattern: 'uploadFile', suggestion: 'upload', confidence: 0.95, reason: 'Use "upload" instead of "uploadFile"' },
+      { pattern: 'deleteFile', suggestion: 'deleteFile', confidence: 1.0, reason: 'Exact match' },
+      { pattern: 'downloadFile', suggestion: 'download', confidence: 0.95, reason: 'Use "download" instead of "downloadFile"' },
+      { pattern: 'getFile', suggestion: 'download', confidence: 0.8, reason: 'Use "download" to retrieve file content' },
+      { pattern: 'listFolders', suggestion: 'search', confidence: 0.85, reason: 'Use "search" with resource: "fileFolder"' },
+    ]);
+
+    // Slack patterns
+    patterns.set('slack', [
+      { pattern: 'sendMessage', suggestion: 'send', confidence: 0.95, reason: 'Use "send" instead of "sendMessage"' },
+      { pattern: 'getMessage', suggestion: 'get', confidence: 0.9, reason: 'Use "get" to retrieve messages' },
+      { pattern: 'postMessage', suggestion: 'send', confidence: 0.9, reason: 'Use "send" to post messages' },
+      { pattern: 'deleteMessage', suggestion: 'delete', confidence: 0.95, reason: 'Use "delete" instead of "deleteMessage"' },
+      { pattern: 'createChannel', suggestion: 'create', confidence: 0.9, reason: 'Use "create" with resource: "channel"' },
+    ]);
+
+    // Database patterns (postgres, mysql, mongodb)
+    patterns.set('database', [
+      { pattern: 'selectData', suggestion: 'select', confidence: 0.95, reason: 'Use "select" instead of "selectData"' },
+      { pattern: 'insertData', suggestion: 'insert', confidence: 0.95, reason: 'Use "insert" instead of "insertData"' },
+      { pattern: 'updateData', suggestion: 'update', confidence: 0.95, reason: 'Use "update" instead of "updateData"' },
+      { pattern: 'deleteData', suggestion: 'delete', confidence: 0.95, reason: 'Use "delete" instead of "deleteData"' },
+      { pattern: 'query', suggestion: 'select', confidence: 0.7, reason: 'Use "select" for queries' },
+      { pattern: 'fetch', suggestion: 'select', confidence: 0.7, reason: 'Use "select" to fetch data' },
+    ]);
+
+    // HTTP patterns
+    patterns.set('httpRequest', [
+      { pattern: 'fetch', suggestion: 'GET', confidence: 0.8, reason: 'Use "GET" method for fetching data' },
+      { pattern: 'send', suggestion: 'POST', confidence: 0.7, reason: 'Use "POST" method for sending data' },
+      { pattern: 'create', suggestion: 'POST', confidence: 0.8, reason: 'Use "POST" method for creating resources' },
+      { pattern: 'update', suggestion: 'PUT', confidence: 0.8, reason: 'Use "PUT" method for updating resources' },
+      { pattern: 'delete', suggestion: 'DELETE', confidence: 0.9, reason: 'Use "DELETE" method' },
+    ]);
+
+    // Generic patterns
+    patterns.set('generic', [
+      { pattern: 'list', suggestion: 'get', confidence: 0.6, reason: 'Consider using "get" or "search"' },
+      { pattern: 'retrieve', suggestion: 'get', confidence: 0.8, reason: 'Use "get" to retrieve data' },
+      { pattern: 'fetch', suggestion: 'get', confidence: 0.8, reason: 'Use "get" to fetch data' },
+      { pattern: 'remove', suggestion: 'delete', confidence: 0.85, reason: 'Use "delete" to remove items' },
+      { pattern: 'add', suggestion: 'create', confidence: 0.7, reason: 'Use "create" to add new items' },
+    ]);
+
+    return patterns;
+  }
+
+  /**
+   * Find similar operations for an invalid operation using Levenshtein distance
+   * and pattern matching algorithms
+   *
+   * @param nodeType - The n8n node type (e.g., 'nodes-base.slack')
+   * @param invalidOperation - The invalid operation provided by the user
+   * @param resource - Optional resource to filter operations
+   * @param maxSuggestions - Maximum number of suggestions to return (default: 5)
+   * @returns Array of operation suggestions sorted by confidence
+   *
+   * @example
+   * findSimilarOperations('nodes-base.googleDrive', 'listFiles', 'fileFolder')
+   * // Returns: [{ value: 'search', confidence: 0.85, reason: 'Use "search" with resource: "fileFolder" to list files' }]
+   */
+  findSimilarOperations(
+    nodeType: string,
+    invalidOperation: string,
+    resource?: string,
+    maxSuggestions: number = OperationSimilarityService.MAX_SUGGESTIONS
+  ): OperationSuggestion[] {
+    // Clean up expired cache entries periodically
+    if (Math.random() < 0.1) { // 10% chance to cleanup on each call
+      this.cleanupExpiredEntries();
+    }
+    // Check cache first
+    const cacheKey = `${nodeType}:${invalidOperation}:${resource || ''}`;
+    if (this.suggestionCache.has(cacheKey)) {
+      return this.suggestionCache.get(cacheKey)!;
+    }
+
+    const suggestions: OperationSuggestion[] = [];
+
+    // Get valid operations for the node
+    let nodeInfo;
+    try {
+      nodeInfo = this.repository.getNode(nodeType);
+      if (!nodeInfo) {
+        return [];
+      }
+    } catch (error) {
+      logger.warn(`Error getting node ${nodeType}:`, error);
+      return [];
+    }
+
+    const validOperations = this.getNodeOperations(nodeType, resource);
+
+    // Early termination for exact match - no suggestions needed
+    for (const op of validOperations) {
+      const opValue = this.getOperationValue(op);
+      if (opValue.toLowerCase() === invalidOperation.toLowerCase()) {
+        return []; // Valid operation, no suggestions needed
+      }
+    }
+
+    // Check for exact pattern matches first
+    const nodePatterns = this.getNodePatterns(nodeType);
+    for (const pattern of nodePatterns) {
+      if (pattern.pattern.toLowerCase() === invalidOperation.toLowerCase()) {
+        // Type-safe operation value extraction
+        const exists = validOperations.some(op => {
+          const opValue = this.getOperationValue(op);
+          return opValue === pattern.suggestion;
+        });
+        if (exists) {
+          suggestions.push({
+            value: pattern.suggestion,
+            confidence: pattern.confidence,
+            reason: pattern.reason,
+            resource
+          });
+        }
+      }
+    }
+
+    // Calculate similarity for all valid operations
+    for (const op of validOperations) {
+      const opValue = this.getOperationValue(op);
+
+      const similarity = this.calculateSimilarity(invalidOperation, opValue);
+
+      if (similarity >= OperationSimilarityService.MIN_CONFIDENCE) {
+        // Don't add if already suggested by pattern
+        if (!suggestions.some(s => s.value === opValue)) {
+          suggestions.push({
+            value: opValue,
+            confidence: similarity,
+            reason: this.getSimilarityReason(similarity, invalidOperation, opValue),
+            resource: typeof op === 'object' ? op.resource : undefined,
+            description: typeof op === 'object' ? (op.description || op.name) : undefined
+          });
+        }
+      }
+    }
+
+    // Sort by confidence and limit
+    suggestions.sort((a, b) => b.confidence - a.confidence);
+    const topSuggestions = suggestions.slice(0, maxSuggestions);
+
+    // Cache the result
+    this.suggestionCache.set(cacheKey, topSuggestions);
+
+    return topSuggestions;
+  }
+
+  /**
+   * Type-safe extraction of operation value from various formats
+   * @param op - Operation object or string
+   * @returns The operation value as a string
+   */
+  private getOperationValue(op: any): string {
+    if (typeof op === 'string') {
+      return op;
+    }
+    if (typeof op === 'object' && op !== null) {
+      return op.operation || op.value || '';
+    }
+    return '';
+  }
+
+  /**
+   * Type-safe extraction of resource value
+   * @param resource - Resource object or string
+   * @returns The resource value as a string
+   */
+  private getResourceValue(resource: any): string {
+    if (typeof resource === 'string') {
+      return resource;
+    }
+    if (typeof resource === 'object' && resource !== null) {
+      return resource.value || '';
+    }
+    return '';
+  }
+
+  /**
+   * Get operations for a node, handling resource filtering
+   */
+  private getNodeOperations(nodeType: string, resource?: string): any[] {
+    // Cleanup cache periodically
+    if (Math.random() < 0.05) { // 5% chance
+      this.cleanupExpiredEntries();
+    }
+
+    const cacheKey = `${nodeType}:${resource || 'all'}`;
+    const cached = this.operationCache.get(cacheKey);
+
+    if (cached && Date.now() - cached.timestamp < OperationSimilarityService.CACHE_DURATION_MS) {
+      return cached.operations;
+    }
+
+    const nodeInfo = this.repository.getNode(nodeType);
+    if (!nodeInfo) return [];
+
+    let operations: any[] = [];
+
+    // Parse operations from the node with safe JSON parsing
+    try {
+      const opsData = nodeInfo.operations;
+      if (typeof opsData === 'string') {
+        // Safe JSON parsing
+        try {
+          operations = JSON.parse(opsData);
+        } catch (parseError) {
+          logger.error(`JSON parse error for operations in ${nodeType}:`, parseError);
+          throw ValidationServiceError.jsonParseError(nodeType, parseError as Error);
+        }
+      } else if (Array.isArray(opsData)) {
+        operations = opsData;
+      } else if (opsData && typeof opsData === 'object') {
+        operations = Object.values(opsData).flat();
+      }
+    } catch (error) {
+      // Re-throw ValidationServiceError, log and continue for others
+      if (error instanceof ValidationServiceError) {
+        throw error;
+      }
+      logger.warn(`Failed to process operations for ${nodeType}:`, error);
+    }
+
+    // Also check properties for operation fields
+    try {
+      const properties = nodeInfo.properties || [];
+      for (const prop of properties) {
+        if (prop.name === 'operation' && prop.options) {
+          // Filter by resource if specified
+          if (prop.displayOptions?.show?.resource) {
+            const allowedResources = Array.isArray(prop.displayOptions.show.resource)
+              ? prop.displayOptions.show.resource
+              : [prop.displayOptions.show.resource];
+            // Only filter if a specific resource is requested
+            if (resource && !allowedResources.includes(resource)) {
+              continue;
+            }
+            // If no resource specified, include all operations
+          }
+
+          operations.push(...prop.options.map((opt: any) => ({
+            operation: opt.value,
+            name: opt.name,
+            description: opt.description,
+            resource
+          })));
+        }
+      }
+    } catch (error) {
+      logger.warn(`Failed to extract operations from properties for ${nodeType}:`, error);
+    }
+
+    // Cache and return
+    this.operationCache.set(cacheKey, { operations, timestamp: Date.now() });
+    return operations;
+  }
+
+  /**
+   * Get patterns for a specific node type
+   */
+  private getNodePatterns(nodeType: string): OperationPattern[] {
+    const patterns: OperationPattern[] = [];
+
+    // Add node-specific patterns
+    if (nodeType.includes('googleDrive')) {
+      patterns.push(...(this.commonPatterns.get('googleDrive') || []));
+    } else if (nodeType.includes('slack')) {
+      patterns.push(...(this.commonPatterns.get('slack') || []));
+    } else if (nodeType.includes('postgres') || nodeType.includes('mysql') || nodeType.includes('mongodb')) {
+      patterns.push(...(this.commonPatterns.get('database') || []));
+    } else if (nodeType.includes('httpRequest')) {
+      patterns.push(...(this.commonPatterns.get('httpRequest') || []));
+    }
+
+    // Always add generic patterns
+    patterns.push(...(this.commonPatterns.get('generic') || []));
+
+    return patterns;
+  }
+
+  /**
+   * Calculate similarity between two strings using Levenshtein distance
+   */
+  private calculateSimilarity(str1: string, str2: string): number {
+    const s1 = str1.toLowerCase();
+    const s2 = str2.toLowerCase();
+
+    // Exact match
+    if (s1 === s2) return 1.0;
+
+    // One is substring of the other
+    if (s1.includes(s2) || s2.includes(s1)) {
+      const ratio = Math.min(s1.length, s2.length) / Math.max(s1.length, s2.length);
+      return Math.max(OperationSimilarityService.CONFIDENCE_THRESHOLDS.MIN_SUBSTRING, ratio);
+    }
+
+    // Calculate Levenshtein distance
+    const distance = this.levenshteinDistance(s1, s2);
+    const maxLength = Math.max(s1.length, s2.length);
+
+    // Convert distance to similarity (0 to 1)
+    let similarity = 1 - (distance / maxLength);
+
+    // Boost confidence for single character typos and transpositions in short words
+    if (distance === 1 && maxLength <= 5) {
+      similarity = Math.max(similarity, 0.75);
+    } else if (distance === 2 && maxLength <= 5) {
+      // Boost for transpositions
+      similarity = Math.max(similarity, 0.72);
+    }
+
+    // Boost similarity for common patterns
+    if (this.areCommonVariations(s1, s2)) {
+      return Math.min(1.0, similarity + 0.2);
+    }
+
+    return similarity;
+  }
+
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  private levenshteinDistance(str1: string, str2: string): number {
+    const m = str1.length;
+    const n = str2.length;
+    const dp: number[][] = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (str1[i - 1] === str2[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = Math.min(
+            dp[i - 1][j] + 1,    // deletion
+            dp[i][j - 1] + 1,    // insertion
+            dp[i - 1][j - 1] + 1 // substitution
+          );
+        }
+      }
+    }
+
+    return dp[m][n];
+  }
+
+  /**
+   * Check if two strings are common variations
+   */
+  private areCommonVariations(str1: string, str2: string): boolean {
+    // Handle edge cases first
+    if (str1 === '' || str2 === '' || str1 === str2) {
+      return false;
+    }
+
+    // Check for common prefixes/suffixes
+    const commonPrefixes = ['get', 'set', 'create', 'delete', 'update', 'send', 'fetch'];
+    const commonSuffixes = ['data', 'item', 'record', 'message', 'file', 'folder'];
+
+    for (const prefix of commonPrefixes) {
+      if ((str1.startsWith(prefix) && !str2.startsWith(prefix)) ||
+          (!str1.startsWith(prefix) && str2.startsWith(prefix))) {
+        const s1Clean = str1.startsWith(prefix) ? str1.slice(prefix.length) : str1;
+        const s2Clean = str2.startsWith(prefix) ? str2.slice(prefix.length) : str2;
+        // Only return true if at least one string was actually cleaned (not empty after cleaning)
+        if ((str1.startsWith(prefix) && s1Clean !== str1) || (str2.startsWith(prefix) && s2Clean !== str2)) {
+          if (s1Clean === s2Clean || this.levenshteinDistance(s1Clean, s2Clean) <= 2) {
+            return true;
+          }
+        }
+      }
+    }
+
+    for (const suffix of commonSuffixes) {
+      if ((str1.endsWith(suffix) && !str2.endsWith(suffix)) ||
+          (!str1.endsWith(suffix) && str2.endsWith(suffix))) {
+        const s1Clean = str1.endsWith(suffix) ? str1.slice(0, -suffix.length) : str1;
+        const s2Clean = str2.endsWith(suffix) ? str2.slice(0, -suffix.length) : str2;
+        // Only return true if at least one string was actually cleaned (not empty after cleaning)
+        if ((str1.endsWith(suffix) && s1Clean !== str1) || (str2.endsWith(suffix) && s2Clean !== str2)) {
+          if (s1Clean === s2Clean || this.levenshteinDistance(s1Clean, s2Clean) <= 2) {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Generate a human-readable reason for the similarity
+   * @param confidence - Similarity confidence score
+   * @param invalid - The invalid operation string
+   * @param valid - The valid operation string
+   * @returns Human-readable explanation of the similarity
+   */
+  private getSimilarityReason(confidence: number, invalid: string, valid: string): string {
+    const { VERY_HIGH, HIGH, MEDIUM } = OperationSimilarityService.CONFIDENCE_THRESHOLDS;
+
+    if (confidence >= VERY_HIGH) {
+      return 'Almost exact match - likely a typo';
+    } else if (confidence >= HIGH) {
+      return 'Very similar - common variation';
+    } else if (confidence >= MEDIUM) {
+      return 'Similar operation';
+    } else if (invalid.includes(valid) || valid.includes(invalid)) {
+      return 'Partial match';
+    } else {
+      return 'Possibly related operation';
+    }
+  }
+
+  /**
+   * Clear caches
+   */
+  clearCache(): void {
+    this.operationCache.clear();
+    this.suggestionCache.clear();
+  }
+}

src/services/resource-similarity-service.ts

@@ -0,0 +1,522 @@
+import { NodeRepository } from '../database/node-repository';
+import { logger } from '../utils/logger';
+import { ValidationServiceError } from '../errors/validation-service-error';
+
+export interface ResourceSuggestion {
+  value: string;
+  confidence: number;
+  reason: string;
+  availableOperations?: string[];
+}
+
+interface ResourcePattern {
+  pattern: string;
+  suggestion: string;
+  confidence: number;
+  reason: string;
+}
+
+export class ResourceSimilarityService {
+  private static readonly CACHE_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+  private static readonly MIN_CONFIDENCE = 0.3; // 30% minimum confidence to suggest
+  private static readonly MAX_SUGGESTIONS = 5;
+
+  // Confidence thresholds for better code clarity
+  private static readonly CONFIDENCE_THRESHOLDS = {
+    EXACT: 1.0,
+    VERY_HIGH: 0.95,
+    HIGH: 0.8,
+    MEDIUM: 0.6,
+    MIN_SUBSTRING: 0.7
+  } as const;
+
+  private repository: NodeRepository;
+  private resourceCache: Map<string, { resources: any[], timestamp: number }> = new Map();
+  private suggestionCache: Map<string, ResourceSuggestion[]> = new Map();
+  private commonPatterns: Map<string, ResourcePattern[]>;
+
+  constructor(repository: NodeRepository) {
+    this.repository = repository;
+    this.commonPatterns = this.initializeCommonPatterns();
+  }
+
+  /**
+   * Clean up expired cache entries to prevent memory leaks
+   */
+  private cleanupExpiredEntries(): void {
+    const now = Date.now();
+
+    // Clean resource cache
+    for (const [key, value] of this.resourceCache.entries()) {
+      if (now - value.timestamp >= ResourceSimilarityService.CACHE_DURATION_MS) {
+        this.resourceCache.delete(key);
+      }
+    }
+
+    // Clean suggestion cache - these don't have timestamps, so clear if cache is too large
+    if (this.suggestionCache.size > 100) {
+      // Keep only the most recent 50 entries
+      const entries = Array.from(this.suggestionCache.entries());
+      this.suggestionCache.clear();
+      entries.slice(-50).forEach(([key, value]) => {
+        this.suggestionCache.set(key, value);
+      });
+    }
+  }
+
+  /**
+   * Initialize common resource mistake patterns
+   */
+  private initializeCommonPatterns(): Map<string, ResourcePattern[]> {
+    const patterns = new Map<string, ResourcePattern[]>();
+
+    // Google Drive patterns
+    patterns.set('googleDrive', [
+      { pattern: 'files', suggestion: 'file', confidence: 0.95, reason: 'Use singular "file" not plural' },
+      { pattern: 'folders', suggestion: 'folder', confidence: 0.95, reason: 'Use singular "folder" not plural' },
+      { pattern: 'permissions', suggestion: 'permission', confidence: 0.9, reason: 'Use singular form' },
+      { pattern: 'fileAndFolder', suggestion: 'fileFolder', confidence: 0.9, reason: 'Use "fileFolder" for combined operations' },
+      { pattern: 'driveFiles', suggestion: 'file', confidence: 0.8, reason: 'Use "file" for file operations' },
+      { pattern: 'sharedDrives', suggestion: 'drive', confidence: 0.85, reason: 'Use "drive" for shared drive operations' },
+    ]);
+
+    // Slack patterns
+    patterns.set('slack', [
+      { pattern: 'messages', suggestion: 'message', confidence: 0.95, reason: 'Use singular "message" not plural' },
+      { pattern: 'channels', suggestion: 'channel', confidence: 0.95, reason: 'Use singular "channel" not plural' },
+      { pattern: 'users', suggestion: 'user', confidence: 0.95, reason: 'Use singular "user" not plural' },
+      { pattern: 'msg', suggestion: 'message', confidence: 0.85, reason: 'Use full "message" not abbreviation' },
+      { pattern: 'dm', suggestion: 'message', confidence: 0.7, reason: 'Use "message" for direct messages' },
+      { pattern: 'conversation', suggestion: 'channel', confidence: 0.7, reason: 'Use "channel" for conversations' },
+    ]);
+
+    // Database patterns (postgres, mysql, mongodb)
+    patterns.set('database', [
+      { pattern: 'tables', suggestion: 'table', confidence: 0.95, reason: 'Use singular "table" not plural' },
+      { pattern: 'queries', suggestion: 'query', confidence: 0.95, reason: 'Use singular "query" not plural' },
+      { pattern: 'collections', suggestion: 'collection', confidence: 0.95, reason: 'Use singular "collection" not plural' },
+      { pattern: 'documents', suggestion: 'document', confidence: 0.95, reason: 'Use singular "document" not plural' },
+      { pattern: 'records', suggestion: 'record', confidence: 0.85, reason: 'Use "record" or "document"' },
+      { pattern: 'rows', suggestion: 'row', confidence: 0.9, reason: 'Use singular "row"' },
+    ]);
+
+    // Google Sheets patterns
+    patterns.set('googleSheets', [
+      { pattern: 'sheets', suggestion: 'sheet', confidence: 0.95, reason: 'Use singular "sheet" not plural' },
+      { pattern: 'spreadsheets', suggestion: 'spreadsheet', confidence: 0.95, reason: 'Use singular "spreadsheet"' },
+      { pattern: 'cells', suggestion: 'cell', confidence: 0.9, reason: 'Use singular "cell"' },
+      { pattern: 'ranges', suggestion: 'range', confidence: 0.9, reason: 'Use singular "range"' },
+      { pattern: 'worksheets', suggestion: 'sheet', confidence: 0.8, reason: 'Use "sheet" for worksheet operations' },
+    ]);
+
+    // Email patterns
+    patterns.set('email', [
+      { pattern: 'emails', suggestion: 'email', confidence: 0.95, reason: 'Use singular "email" not plural' },
+      { pattern: 'messages', suggestion: 'message', confidence: 0.9, reason: 'Use "message" for email operations' },
+      { pattern: 'mails', suggestion: 'email', confidence: 0.9, reason: 'Use "email" not "mail"' },
+      { pattern: 'attachments', suggestion: 'attachment', confidence: 0.95, reason: 'Use singular "attachment"' },
+    ]);
+
+    // Generic plural/singular patterns
+    patterns.set('generic', [
+      { pattern: 'items', suggestion: 'item', confidence: 0.9, reason: 'Use singular form' },
+      { pattern: 'objects', suggestion: 'object', confidence: 0.9, reason: 'Use singular form' },
+      { pattern: 'entities', suggestion: 'entity', confidence: 0.9, reason: 'Use singular form' },
+      { pattern: 'resources', suggestion: 'resource', confidence: 0.9, reason: 'Use singular form' },
+      { pattern: 'elements', suggestion: 'element', confidence: 0.9, reason: 'Use singular form' },
+    ]);
+
+    return patterns;
+  }
+
+  /**
+   * Find similar resources for an invalid resource using pattern matching
+   * and Levenshtein distance algorithms
+   *
+   * @param nodeType - The n8n node type (e.g., 'nodes-base.googleDrive')
+   * @param invalidResource - The invalid resource provided by the user
+   * @param maxSuggestions - Maximum number of suggestions to return (default: 5)
+   * @returns Array of resource suggestions sorted by confidence
+   *
+   * @example
+   * findSimilarResources('nodes-base.googleDrive', 'files', 3)
+   * // Returns: [{ value: 'file', confidence: 0.95, reason: 'Use singular "file" not plural' }]
+   */
+  findSimilarResources(
+    nodeType: string,
+    invalidResource: string,
+    maxSuggestions: number = ResourceSimilarityService.MAX_SUGGESTIONS
+  ): ResourceSuggestion[] {
+    // Clean up expired cache entries periodically
+    if (Math.random() < 0.1) { // 10% chance to cleanup on each call
+      this.cleanupExpiredEntries();
+    }
+    // Check cache first
+    const cacheKey = `${nodeType}:${invalidResource}`;
+    if (this.suggestionCache.has(cacheKey)) {
+      return this.suggestionCache.get(cacheKey)!;
+    }
+
+    const suggestions: ResourceSuggestion[] = [];
+
+    // Get valid resources for the node
+    const validResources = this.getNodeResources(nodeType);
+
+    // Early termination for exact match - no suggestions needed
+    for (const resource of validResources) {
+      const resourceValue = this.getResourceValue(resource);
+      if (resourceValue.toLowerCase() === invalidResource.toLowerCase()) {
+        return []; // Valid resource, no suggestions needed
+      }
+    }
+
+    // Check for exact pattern matches first
+    const nodePatterns = this.getNodePatterns(nodeType);
+    for (const pattern of nodePatterns) {
+      if (pattern.pattern.toLowerCase() === invalidResource.toLowerCase()) {
+        // Check if the suggested resource actually exists with type safety
+        const exists = validResources.some(r => {
+          const resourceValue = this.getResourceValue(r);
+          return resourceValue === pattern.suggestion;
+        });
+        if (exists) {
+          suggestions.push({
+            value: pattern.suggestion,
+            confidence: pattern.confidence,
+            reason: pattern.reason
+          });
+        }
+      }
+    }
+
+    // Handle automatic plural/singular conversion
+    const singularForm = this.toSingular(invalidResource);
+    const pluralForm = this.toPlural(invalidResource);
+
+    for (const resource of validResources) {
+      const resourceValue = this.getResourceValue(resource);
+
+      // Check for plural/singular match
+      if (resourceValue === singularForm || resourceValue === pluralForm) {
+        if (!suggestions.some(s => s.value === resourceValue)) {
+          suggestions.push({
+            value: resourceValue,
+            confidence: 0.9,
+            reason: invalidResource.endsWith('s') ?
+              'Use singular form for resources' :
+              'Incorrect plural/singular form',
+            availableOperations: typeof resource === 'object' ? resource.operations : undefined
+          });
+        }
+      }
+
+      // Calculate similarity
+      const similarity = this.calculateSimilarity(invalidResource, resourceValue);
+      if (similarity >= ResourceSimilarityService.MIN_CONFIDENCE) {
+        if (!suggestions.some(s => s.value === resourceValue)) {
+          suggestions.push({
+            value: resourceValue,
+            confidence: similarity,
+            reason: this.getSimilarityReason(similarity, invalidResource, resourceValue),
+            availableOperations: typeof resource === 'object' ? resource.operations : undefined
+          });
+        }
+      }
+    }
+
+    // Sort by confidence and limit
+    suggestions.sort((a, b) => b.confidence - a.confidence);
+    const topSuggestions = suggestions.slice(0, maxSuggestions);
+
+    // Cache the result
+    this.suggestionCache.set(cacheKey, topSuggestions);
+
+    return topSuggestions;
+  }
+
+  /**
+   * Type-safe extraction of resource value from various formats
+   * @param resource - Resource object or string
+   * @returns The resource value as a string
+   */
+  private getResourceValue(resource: any): string {
+    if (typeof resource === 'string') {
+      return resource;
+    }
+    if (typeof resource === 'object' && resource !== null) {
+      return resource.value || '';
+    }
+    return '';
+  }
+
+  /**
+   * Get resources for a node with caching
+   */
+  private getNodeResources(nodeType: string): any[] {
+    // Cleanup cache periodically
+    if (Math.random() < 0.05) { // 5% chance
+      this.cleanupExpiredEntries();
+    }
+
+    const cacheKey = nodeType;
+    const cached = this.resourceCache.get(cacheKey);
+
+    if (cached && Date.now() - cached.timestamp < ResourceSimilarityService.CACHE_DURATION_MS) {
+      return cached.resources;
+    }
+
+    const nodeInfo = this.repository.getNode(nodeType);
+    if (!nodeInfo) return [];
+
+    const resources: any[] = [];
+    const resourceMap: Map<string, string[]> = new Map();
+
+    // Parse properties for resource fields
+    try {
+      const properties = nodeInfo.properties || [];
+      for (const prop of properties) {
+        if (prop.name === 'resource' && prop.options) {
+          for (const option of prop.options) {
+            resources.push({
+              value: option.value,
+              name: option.name,
+              operations: []
+            });
+            resourceMap.set(option.value, []);
+          }
+        }
+
+        // Find operations for each resource
+        if (prop.name === 'operation' && prop.displayOptions?.show?.resource) {
+          const resourceValues = Array.isArray(prop.displayOptions.show.resource)
+            ? prop.displayOptions.show.resource
+            : [prop.displayOptions.show.resource];
+
+          for (const resourceValue of resourceValues) {
+            if (resourceMap.has(resourceValue) && prop.options) {
+              const ops = prop.options.map((op: any) => op.value);
+              resourceMap.get(resourceValue)!.push(...ops);
+            }
+          }
+        }
+      }
+
+      // Update resources with their operations
+      for (const resource of resources) {
+        if (resourceMap.has(resource.value)) {
+          resource.operations = resourceMap.get(resource.value);
+        }
+      }
+
+      // If no explicit resources, check for common patterns
+      if (resources.length === 0) {
+        // Some nodes don't have explicit resource fields
+        const implicitResources = this.extractImplicitResources(properties);
+        resources.push(...implicitResources);
+      }
+    } catch (error) {
+      logger.warn(`Failed to extract resources for ${nodeType}:`, error);
+    }
+
+    // Cache and return
+    this.resourceCache.set(cacheKey, { resources, timestamp: Date.now() });
+    return resources;
+  }
+
+  /**
+   * Extract implicit resources from node properties
+   */
+  private extractImplicitResources(properties: any[]): any[] {
+    const resources: any[] = [];
+
+    // Look for properties that suggest resources
+    for (const prop of properties) {
+      if (prop.name === 'operation' && prop.options) {
+        // If there's no explicit resource field, operations might imply resources
+        const resourceFromOps = this.inferResourceFromOperations(prop.options);
+        if (resourceFromOps) {
+          resources.push({
+            value: resourceFromOps,
+            name: resourceFromOps.charAt(0).toUpperCase() + resourceFromOps.slice(1),
+            operations: prop.options.map((op: any) => op.value)
+          });
+        }
+      }
+    }
+
+    return resources;
+  }
+
+  /**
+   * Infer resource type from operations
+   */
+  private inferResourceFromOperations(operations: any[]): string | null {
+    // Common patterns in operation names that suggest resources
+    const patterns = [
+      { keywords: ['file', 'upload', 'download'], resource: 'file' },
+      { keywords: ['folder', 'directory'], resource: 'folder' },
+      { keywords: ['message', 'send', 'reply'], resource: 'message' },
+      { keywords: ['channel', 'broadcast'], resource: 'channel' },
+      { keywords: ['user', 'member'], resource: 'user' },
+      { keywords: ['table', 'row', 'column'], resource: 'table' },
+      { keywords: ['document', 'doc'], resource: 'document' },
+    ];
+
+    for (const pattern of patterns) {
+      for (const op of operations) {
+        const opName = (op.value || op).toLowerCase();
+        if (pattern.keywords.some(keyword => opName.includes(keyword))) {
+          return pattern.resource;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get patterns for a specific node type
+   */
+  private getNodePatterns(nodeType: string): ResourcePattern[] {
+    const patterns: ResourcePattern[] = [];
+
+    // Add node-specific patterns
+    if (nodeType.includes('googleDrive')) {
+      patterns.push(...(this.commonPatterns.get('googleDrive') || []));
+    } else if (nodeType.includes('slack')) {
+      patterns.push(...(this.commonPatterns.get('slack') || []));
+    } else if (nodeType.includes('postgres') || nodeType.includes('mysql') || nodeType.includes('mongodb')) {
+      patterns.push(...(this.commonPatterns.get('database') || []));
+    } else if (nodeType.includes('googleSheets')) {
+      patterns.push(...(this.commonPatterns.get('googleSheets') || []));
+    } else if (nodeType.includes('gmail') || nodeType.includes('email')) {
+      patterns.push(...(this.commonPatterns.get('email') || []));
+    }
+
+    // Always add generic patterns
+    patterns.push(...(this.commonPatterns.get('generic') || []));
+
+    return patterns;
+  }
+
+  /**
+   * Convert to singular form (simple heuristic)
+   */
+  private toSingular(word: string): string {
+    if (word.endsWith('ies')) {
+      return word.slice(0, -3) + 'y';
+    } else if (word.endsWith('es')) {
+      return word.slice(0, -2);
+    } else if (word.endsWith('s') && !word.endsWith('ss')) {
+      return word.slice(0, -1);
+    }
+    return word;
+  }
+
+  /**
+   * Convert to plural form (simple heuristic)
+   */
+  private toPlural(word: string): string {
+    if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].includes(word.slice(-2))) {
+      return word.slice(0, -1) + 'ies';
+    } else if (word.endsWith('s') || word.endsWith('x') || word.endsWith('z') ||
+               word.endsWith('ch') || word.endsWith('sh')) {
+      return word + 'es';
+    } else {
+      return word + 's';
+    }
+  }
+
+  /**
+   * Calculate similarity between two strings using Levenshtein distance
+   */
+  private calculateSimilarity(str1: string, str2: string): number {
+    const s1 = str1.toLowerCase();
+    const s2 = str2.toLowerCase();
+
+    // Exact match
+    if (s1 === s2) return 1.0;
+
+    // One is substring of the other
+    if (s1.includes(s2) || s2.includes(s1)) {
+      const ratio = Math.min(s1.length, s2.length) / Math.max(s1.length, s2.length);
+      return Math.max(ResourceSimilarityService.CONFIDENCE_THRESHOLDS.MIN_SUBSTRING, ratio);
+    }
+
+    // Calculate Levenshtein distance
+    const distance = this.levenshteinDistance(s1, s2);
+    const maxLength = Math.max(s1.length, s2.length);
+
+    // Convert distance to similarity
+    let similarity = 1 - (distance / maxLength);
+
+    // Boost confidence for single character typos and transpositions in short words
+    if (distance === 1 && maxLength <= 5) {
+      similarity = Math.max(similarity, 0.75);
+    } else if (distance === 2 && maxLength <= 5) {
+      // Boost for transpositions (e.g., "flie" -> "file")
+      similarity = Math.max(similarity, 0.72);
+    }
+
+    return similarity;
+  }
+
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  private levenshteinDistance(str1: string, str2: string): number {
+    const m = str1.length;
+    const n = str2.length;
+    const dp: number[][] = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (str1[i - 1] === str2[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = Math.min(
+            dp[i - 1][j] + 1,    // deletion
+            dp[i][j - 1] + 1,    // insertion
+            dp[i - 1][j - 1] + 1 // substitution
+          );
+        }
+      }
+    }
+
+    return dp[m][n];
+  }
+
+  /**
+   * Generate a human-readable reason for the similarity
+   * @param confidence - Similarity confidence score
+   * @param invalid - The invalid resource string
+   * @param valid - The valid resource string
+   * @returns Human-readable explanation of the similarity
+   */
+  private getSimilarityReason(confidence: number, invalid: string, valid: string): string {
+    const { VERY_HIGH, HIGH, MEDIUM } = ResourceSimilarityService.CONFIDENCE_THRESHOLDS;
+
+    if (confidence >= VERY_HIGH) {
+      return 'Almost exact match - likely a typo';
+    } else if (confidence >= HIGH) {
+      return 'Very similar - common variation';
+    } else if (confidence >= MEDIUM) {
+      return 'Similar resource name';
+    } else if (invalid.includes(valid) || valid.includes(invalid)) {
+      return 'Partial match';
+    } else {
+      return 'Possibly related resource';
+    }
+  }
+
+  /**
+   * Clear caches
+   */
+  clearCache(): void {
+    this.resourceCache.clear();
+    this.suggestionCache.clear();
+  }
+}

src/services/task-templates.ts

@@ -1,6 +1,14 @@
 /**
  * Task Templates Service
- * 
+ *
+ * @deprecated This module is deprecated as of v2.15.0 and will be removed in v2.16.0.
+ * The get_node_for_task tool has been removed in favor of template-based configuration examples.
+ *
+ * Migration:
+ * - Use `search_nodes({query: "webhook", includeExamples: true})` to find nodes with real template configs
+ * - Use `get_node_essentials({nodeType: "nodes-base.webhook", includeExamples: true})` for top 3 examples
+ * - New approach provides 2,646 real templates vs 31 hardcoded tasks
+ *
  * Provides pre-configured node settings for common tasks.
  * This helps AI agents quickly configure nodes for specific use cases.
  */

src/services/workflow-auto-fixer.ts

@@ -0,0 +1,630 @@
+/**
+ * Workflow Auto-Fixer Service
+ *
+ * Automatically generates fix operations for common workflow validation errors.
+ * Converts validation results into diff operations that can be applied to fix the workflow.
+ */
+
+import crypto from 'crypto';
+import { WorkflowValidationResult } from './workflow-validator';
+import { ExpressionFormatIssue } from './expression-format-validator';
+import { NodeSimilarityService } from './node-similarity-service';
+import { NodeRepository } from '../database/node-repository';
+import {
+  WorkflowDiffOperation,
+  UpdateNodeOperation
+} from '../types/workflow-diff';
+import { WorkflowNode, Workflow } from '../types/n8n-api';
+import { Logger } from '../utils/logger';
+
+const logger = new Logger({ prefix: '[WorkflowAutoFixer]' });
+
+export type FixConfidenceLevel = 'high' | 'medium' | 'low';
+export type FixType =
+  | 'expression-format'
+  | 'typeversion-correction'
+  | 'error-output-config'
+  | 'node-type-correction'
+  | 'webhook-missing-path';
+
+export interface AutoFixConfig {
+  applyFixes: boolean;
+  fixTypes?: FixType[];
+  confidenceThreshold?: FixConfidenceLevel;
+  maxFixes?: number;
+}
+
+export interface FixOperation {
+  node: string;
+  field: string;
+  type: FixType;
+  before: any;
+  after: any;
+  confidence: FixConfidenceLevel;
+  description: string;
+}
+
+export interface AutoFixResult {
+  operations: WorkflowDiffOperation[];
+  fixes: FixOperation[];
+  summary: string;
+  stats: {
+    total: number;
+    byType: Record<FixType, number>;
+    byConfidence: Record<FixConfidenceLevel, number>;
+  };
+}
+
+export interface NodeFormatIssue extends ExpressionFormatIssue {
+  nodeName: string;
+  nodeId: string;
+}
+
+/**
+ * Type guard to check if an issue has node information
+ */
+export function isNodeFormatIssue(issue: ExpressionFormatIssue): issue is NodeFormatIssue {
+  return 'nodeName' in issue && 'nodeId' in issue &&
+         typeof (issue as any).nodeName === 'string' &&
+         typeof (issue as any).nodeId === 'string';
+}
+
+/**
+ * Error with suggestions for node type issues
+ */
+export interface NodeTypeError {
+  type: 'error';
+  nodeId?: string;
+  nodeName?: string;
+  message: string;
+  suggestions?: Array<{
+    nodeType: string;
+    confidence: number;
+    reason: string;
+  }>;
+}
+
+export class WorkflowAutoFixer {
+  private readonly defaultConfig: AutoFixConfig = {
+    applyFixes: false,
+    confidenceThreshold: 'medium',
+    maxFixes: 50
+  };
+  private similarityService: NodeSimilarityService | null = null;
+
+  constructor(repository?: NodeRepository) {
+    if (repository) {
+      this.similarityService = new NodeSimilarityService(repository);
+    }
+  }
+
+  /**
+   * Generate fix operations from validation results
+   */
+  generateFixes(
+    workflow: Workflow,
+    validationResult: WorkflowValidationResult,
+    formatIssues: ExpressionFormatIssue[] = [],
+    config: Partial<AutoFixConfig> = {}
+  ): AutoFixResult {
+    const fullConfig = { ...this.defaultConfig, ...config };
+    const operations: WorkflowDiffOperation[] = [];
+    const fixes: FixOperation[] = [];
+
+    // Create a map for quick node lookup
+    const nodeMap = new Map<string, WorkflowNode>();
+    workflow.nodes.forEach(node => {
+      nodeMap.set(node.name, node);
+      nodeMap.set(node.id, node);
+    });
+
+    // Process expression format issues (HIGH confidence)
+    if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('expression-format')) {
+      this.processExpressionFormatFixes(formatIssues, nodeMap, operations, fixes);
+    }
+
+    // Process typeVersion errors (MEDIUM confidence)
+    if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('typeversion-correction')) {
+      this.processTypeVersionFixes(validationResult, nodeMap, operations, fixes);
+    }
+
+    // Process error output configuration issues (MEDIUM confidence)
+    if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('error-output-config')) {
+      this.processErrorOutputFixes(validationResult, nodeMap, workflow, operations, fixes);
+    }
+
+    // Process node type corrections (HIGH confidence only)
+    if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('node-type-correction')) {
+      this.processNodeTypeFixes(validationResult, nodeMap, operations, fixes);
+    }
+
+    // Process webhook path fixes (HIGH confidence)
+    if (!fullConfig.fixTypes || fullConfig.fixTypes.includes('webhook-missing-path')) {
+      this.processWebhookPathFixes(validationResult, nodeMap, operations, fixes);
+    }
+
+    // Filter by confidence threshold
+    const filteredFixes = this.filterByConfidence(fixes, fullConfig.confidenceThreshold);
+    const filteredOperations = this.filterOperationsByFixes(operations, filteredFixes, fixes);
+
+    // Apply max fixes limit
+    const limitedFixes = filteredFixes.slice(0, fullConfig.maxFixes);
+    const limitedOperations = this.filterOperationsByFixes(filteredOperations, limitedFixes, filteredFixes);
+
+    // Generate summary
+    const stats = this.calculateStats(limitedFixes);
+    const summary = this.generateSummary(stats);
+
+    return {
+      operations: limitedOperations,
+      fixes: limitedFixes,
+      summary,
+      stats
+    };
+  }
+
+  /**
+   * Process expression format fixes (missing = prefix)
+   */
+  private processExpressionFormatFixes(
+    formatIssues: ExpressionFormatIssue[],
+    nodeMap: Map<string, WorkflowNode>,
+    operations: WorkflowDiffOperation[],
+    fixes: FixOperation[]
+  ): void {
+    // Group fixes by node to create single update operation per node
+    const fixesByNode = new Map<string, ExpressionFormatIssue[]>();
+
+    for (const issue of formatIssues) {
+      // Process both errors and warnings for missing-prefix issues
+      if (issue.issueType === 'missing-prefix') {
+        // Use type guard to ensure we have node information
+        if (!isNodeFormatIssue(issue)) {
+          logger.warn('Expression format issue missing node information', {
+            fieldPath: issue.fieldPath,
+            issueType: issue.issueType
+          });
+          continue;
+        }
+
+        const nodeName = issue.nodeName;
+
+        if (!fixesByNode.has(nodeName)) {
+          fixesByNode.set(nodeName, []);
+        }
+        fixesByNode.get(nodeName)!.push(issue);
+      }
+    }
+
+    // Create update operations for each node
+    for (const [nodeName, nodeIssues] of fixesByNode) {
+      const node = nodeMap.get(nodeName);
+      if (!node) continue;
+
+      const updatedParameters = JSON.parse(JSON.stringify(node.parameters || {}));
+
+      for (const issue of nodeIssues) {
+        // Apply the fix to parameters
+        // The fieldPath doesn't include node name, use as is
+        const fieldPath = issue.fieldPath.split('.');
+        this.setNestedValue(updatedParameters, fieldPath, issue.correctedValue);
+
+        fixes.push({
+          node: nodeName,
+          field: issue.fieldPath,
+          type: 'expression-format',
+          before: issue.currentValue,
+          after: issue.correctedValue,
+          confidence: 'high',
+          description: issue.explanation
+        });
+      }
+
+      // Create update operation
+      const operation: UpdateNodeOperation = {
+        type: 'updateNode',
+        nodeId: nodeName, // Can be name or ID
+        updates: {
+          parameters: updatedParameters
+        }
+      };
+      operations.push(operation);
+    }
+  }
+
+  /**
+   * Process typeVersion fixes
+   */
+  private processTypeVersionFixes(
+    validationResult: WorkflowValidationResult,
+    nodeMap: Map<string, WorkflowNode>,
+    operations: WorkflowDiffOperation[],
+    fixes: FixOperation[]
+  ): void {
+    for (const error of validationResult.errors) {
+      if (error.message.includes('typeVersion') && error.message.includes('exceeds maximum')) {
+        // Extract version info from error message
+        const versionMatch = error.message.match(/typeVersion (\d+(?:\.\d+)?) exceeds maximum supported version (\d+(?:\.\d+)?)/);
+        if (versionMatch) {
+          const currentVersion = parseFloat(versionMatch[1]);
+          const maxVersion = parseFloat(versionMatch[2]);
+          const nodeName = error.nodeName || error.nodeId;
+
+          if (!nodeName) continue;
+
+          const node = nodeMap.get(nodeName);
+          if (!node) continue;
+
+          fixes.push({
+            node: nodeName,
+            field: 'typeVersion',
+            type: 'typeversion-correction',
+            before: currentVersion,
+            after: maxVersion,
+            confidence: 'medium',
+            description: `Corrected typeVersion from ${currentVersion} to maximum supported ${maxVersion}`
+          });
+
+          const operation: UpdateNodeOperation = {
+            type: 'updateNode',
+            nodeId: nodeName,
+            updates: {
+              typeVersion: maxVersion
+            }
+          };
+          operations.push(operation);
+        }
+      }
+    }
+  }
+
+  /**
+   * Process error output configuration fixes
+   */
+  private processErrorOutputFixes(
+    validationResult: WorkflowValidationResult,
+    nodeMap: Map<string, WorkflowNode>,
+    workflow: Workflow,
+    operations: WorkflowDiffOperation[],
+    fixes: FixOperation[]
+  ): void {
+    for (const error of validationResult.errors) {
+      if (error.message.includes('onError: \'continueErrorOutput\'') &&
+          error.message.includes('no error output connections')) {
+        const nodeName = error.nodeName || error.nodeId;
+        if (!nodeName) continue;
+
+        const node = nodeMap.get(nodeName);
+        if (!node) continue;
+
+        // Remove the conflicting onError setting
+        fixes.push({
+          node: nodeName,
+          field: 'onError',
+          type: 'error-output-config',
+          before: 'continueErrorOutput',
+          after: undefined,
+          confidence: 'medium',
+          description: 'Removed onError setting due to missing error output connections'
+        });
+
+        const operation: UpdateNodeOperation = {
+          type: 'updateNode',
+          nodeId: nodeName,
+          updates: {
+            onError: undefined // This will remove the property
+          }
+        };
+        operations.push(operation);
+      }
+    }
+  }
+
+  /**
+   * Process node type corrections for unknown nodes
+   */
+  private processNodeTypeFixes(
+    validationResult: WorkflowValidationResult,
+    nodeMap: Map<string, WorkflowNode>,
+    operations: WorkflowDiffOperation[],
+    fixes: FixOperation[]
+  ): void {
+    // Only process if we have the similarity service
+    if (!this.similarityService) {
+      return;
+    }
+
+    for (const error of validationResult.errors) {
+      // Type-safe check for unknown node type errors with suggestions
+      const nodeError = error as NodeTypeError;
+
+      if (error.message?.includes('Unknown node type:') && nodeError.suggestions) {
+        // Only auto-fix if we have a high-confidence suggestion (>= 0.9)
+        const highConfidenceSuggestion = nodeError.suggestions.find(s => s.confidence >= 0.9);
+
+        if (highConfidenceSuggestion && nodeError.nodeId) {
+          const node = nodeMap.get(nodeError.nodeId) || nodeMap.get(nodeError.nodeName || '');
+
+          if (node) {
+            fixes.push({
+              node: node.name,
+              field: 'type',
+              type: 'node-type-correction',
+              before: node.type,
+              after: highConfidenceSuggestion.nodeType,
+              confidence: 'high',
+              description: `Fix node type: "${node.type}" → "${highConfidenceSuggestion.nodeType}" (${highConfidenceSuggestion.reason})`
+            });
+
+            const operation: UpdateNodeOperation = {
+              type: 'updateNode',
+              nodeId: node.name,
+              updates: {
+                type: highConfidenceSuggestion.nodeType
+              }
+            };
+            operations.push(operation);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Process webhook path fixes for webhook nodes missing path parameter
+   */
+  private processWebhookPathFixes(
+    validationResult: WorkflowValidationResult,
+    nodeMap: Map<string, WorkflowNode>,
+    operations: WorkflowDiffOperation[],
+    fixes: FixOperation[]
+  ): void {
+    for (const error of validationResult.errors) {
+      // Check for webhook path required error
+      if (error.message === 'Webhook path is required') {
+        const nodeName = error.nodeName || error.nodeId;
+        if (!nodeName) continue;
+
+        const node = nodeMap.get(nodeName);
+        if (!node) continue;
+
+        // Only fix webhook nodes
+        if (!node.type?.includes('webhook')) continue;
+
+        // Generate a unique UUID for both path and webhookId
+        const webhookId = crypto.randomUUID();
+
+        // Check if we need to update typeVersion
+        const currentTypeVersion = node.typeVersion || 1;
+        const needsVersionUpdate = currentTypeVersion < 2.1;
+
+        fixes.push({
+          node: nodeName,
+          field: 'path',
+          type: 'webhook-missing-path',
+          before: undefined,
+          after: webhookId,
+          confidence: 'high',
+          description: needsVersionUpdate
+            ? `Generated webhook path and ID: ${webhookId} (also updating typeVersion to 2.1)`
+            : `Generated webhook path and ID: ${webhookId}`
+        });
+
+        // Create update operation with both path and webhookId
+        // The updates object uses dot notation for nested properties
+        const updates: Record<string, any> = {
+          'parameters.path': webhookId,
+          'webhookId': webhookId
+        };
+
+        // Only update typeVersion if it's older than 2.1
+        if (needsVersionUpdate) {
+          updates['typeVersion'] = 2.1;
+        }
+
+        const operation: UpdateNodeOperation = {
+          type: 'updateNode',
+          nodeId: nodeName,
+          updates
+        };
+        operations.push(operation);
+      }
+    }
+  }
+
+  /**
+   * Set a nested value in an object using a path array
+   * Includes validation to prevent silent failures
+   */
+  private setNestedValue(obj: any, path: string[], value: any): void {
+    if (!obj || typeof obj !== 'object') {
+      throw new Error('Cannot set value on non-object');
+    }
+
+    if (path.length === 0) {
+      throw new Error('Cannot set value with empty path');
+    }
+
+    try {
+      let current = obj;
+
+      for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+
+        // Handle array indices
+        if (key.includes('[')) {
+          const matches = key.match(/^([^[]+)\[(\d+)\]$/);
+          if (!matches) {
+            throw new Error(`Invalid array notation: ${key}`);
+          }
+
+          const [, arrayKey, indexStr] = matches;
+          const index = parseInt(indexStr, 10);
+
+          if (isNaN(index) || index < 0) {
+            throw new Error(`Invalid array index: ${indexStr}`);
+          }
+
+          if (!current[arrayKey]) {
+            current[arrayKey] = [];
+          }
+
+          if (!Array.isArray(current[arrayKey])) {
+            throw new Error(`Expected array at ${arrayKey}, got ${typeof current[arrayKey]}`);
+          }
+
+          while (current[arrayKey].length <= index) {
+            current[arrayKey].push({});
+          }
+
+          current = current[arrayKey][index];
+        } else {
+          if (current[key] === null || current[key] === undefined) {
+            current[key] = {};
+          }
+
+          if (typeof current[key] !== 'object' || Array.isArray(current[key])) {
+            throw new Error(`Cannot traverse through ${typeof current[key]} at ${key}`);
+          }
+
+          current = current[key];
+        }
+      }
+
+      // Set the final value
+      const lastKey = path[path.length - 1];
+
+      if (lastKey.includes('[')) {
+        const matches = lastKey.match(/^([^[]+)\[(\d+)\]$/);
+        if (!matches) {
+          throw new Error(`Invalid array notation: ${lastKey}`);
+        }
+
+        const [, arrayKey, indexStr] = matches;
+        const index = parseInt(indexStr, 10);
+
+        if (isNaN(index) || index < 0) {
+          throw new Error(`Invalid array index: ${indexStr}`);
+        }
+
+        if (!current[arrayKey]) {
+          current[arrayKey] = [];
+        }
+
+        if (!Array.isArray(current[arrayKey])) {
+          throw new Error(`Expected array at ${arrayKey}, got ${typeof current[arrayKey]}`);
+        }
+
+        while (current[arrayKey].length <= index) {
+          current[arrayKey].push(null);
+        }
+
+        current[arrayKey][index] = value;
+      } else {
+        current[lastKey] = value;
+      }
+    } catch (error) {
+      logger.error('Failed to set nested value', {
+        path: path.join('.'),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Filter fixes by confidence level
+   */
+  private filterByConfidence(
+    fixes: FixOperation[],
+    threshold?: FixConfidenceLevel
+  ): FixOperation[] {
+    if (!threshold) return fixes;
+
+    const levels: FixConfidenceLevel[] = ['high', 'medium', 'low'];
+    const thresholdIndex = levels.indexOf(threshold);
+
+    return fixes.filter(fix => {
+      const fixIndex = levels.indexOf(fix.confidence);
+      return fixIndex <= thresholdIndex;
+    });
+  }
+
+  /**
+   * Filter operations to match filtered fixes
+   */
+  private filterOperationsByFixes(
+    operations: WorkflowDiffOperation[],
+    filteredFixes: FixOperation[],
+    allFixes: FixOperation[]
+  ): WorkflowDiffOperation[] {
+    const fixedNodes = new Set(filteredFixes.map(f => f.node));
+    return operations.filter(op => {
+      if (op.type === 'updateNode') {
+        return fixedNodes.has(op.nodeId || '');
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Calculate statistics about fixes
+   */
+  private calculateStats(fixes: FixOperation[]): AutoFixResult['stats'] {
+    const stats: AutoFixResult['stats'] = {
+      total: fixes.length,
+      byType: {
+        'expression-format': 0,
+        'typeversion-correction': 0,
+        'error-output-config': 0,
+        'node-type-correction': 0,
+        'webhook-missing-path': 0
+      },
+      byConfidence: {
+        'high': 0,
+        'medium': 0,
+        'low': 0
+      }
+    };
+
+    for (const fix of fixes) {
+      stats.byType[fix.type]++;
+      stats.byConfidence[fix.confidence]++;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Generate a human-readable summary
+   */
+  private generateSummary(stats: AutoFixResult['stats']): string {
+    if (stats.total === 0) {
+      return 'No fixes available';
+    }
+
+    const parts: string[] = [];
+
+    if (stats.byType['expression-format'] > 0) {
+      parts.push(`${stats.byType['expression-format']} expression format ${stats.byType['expression-format'] === 1 ? 'error' : 'errors'}`);
+    }
+    if (stats.byType['typeversion-correction'] > 0) {
+      parts.push(`${stats.byType['typeversion-correction']} version ${stats.byType['typeversion-correction'] === 1 ? 'issue' : 'issues'}`);
+    }
+    if (stats.byType['error-output-config'] > 0) {
+      parts.push(`${stats.byType['error-output-config']} error output ${stats.byType['error-output-config'] === 1 ? 'configuration' : 'configurations'}`);
+    }
+    if (stats.byType['node-type-correction'] > 0) {
+      parts.push(`${stats.byType['node-type-correction']} node type ${stats.byType['node-type-correction'] === 1 ? 'correction' : 'corrections'}`);
+    }
+    if (stats.byType['webhook-missing-path'] > 0) {
+      parts.push(`${stats.byType['webhook-missing-path']} webhook ${stats.byType['webhook-missing-path'] === 1 ? 'path' : 'paths'}`);
+    }
+
+    if (parts.length === 0) {
+      return `Fixed ${stats.total} ${stats.total === 1 ? 'issue' : 'issues'}`;
+    }
+
+    return `Fixed ${parts.join(', ')}`;
+  }
+}

src/services/workflow-diff-engine.ts

@@ -4,7 +4,7 @@
  */
 
 import { v4 as uuidv4 } from 'uuid';
-import { 
+import {
   WorkflowDiffOperation,
   WorkflowDiffRequest,
   WorkflowDiffResult,
@@ -24,7 +24,9 @@ import {
   UpdateSettingsOperation,
   UpdateNameOperation,
   AddTagOperation,
-  RemoveTagOperation
+  RemoveTagOperation,
+  CleanStaleConnectionsOperation,
+  ReplaceConnectionsOperation
 } from '../types/workflow-diff';
 import { Workflow, WorkflowNode, WorkflowConnection } from '../types/n8n-api';
 import { Logger } from '../utils/logger';
@@ -37,29 +39,18 @@ export class WorkflowDiffEngine {
    * Apply diff operations to a workflow
    */
   async applyDiff(
-    workflow: Workflow, 
+    workflow: Workflow,
     request: WorkflowDiffRequest
   ): Promise<WorkflowDiffResult> {
     try {
-      // Limit operations to keep complexity manageable
-      if (request.operations.length > 5) {
-        return {
-          success: false,
-          errors: [{
-            operation: -1,
-            message: 'Too many operations. Maximum 5 operations allowed per request to ensure transactional integrity.'
-          }]
-        };
-      }
-
       // Clone workflow to avoid modifying original
       const workflowCopy = JSON.parse(JSON.stringify(workflow));
-      
+
       // Group operations by type for two-pass processing
       const nodeOperationTypes = ['addNode', 'removeNode', 'updateNode', 'moveNode', 'enableNode', 'disableNode'];
       const nodeOperations: Array<{ operation: WorkflowDiffOperation; index: number }> = [];
       const otherOperations: Array<{ operation: WorkflowDiffOperation; index: number }> = [];
-      
+
       request.operations.forEach((operation, index) => {
         if (nodeOperationTypes.includes(operation.type)) {
           nodeOperations.push({ operation, index });
@@ -68,79 +59,137 @@ export class WorkflowDiffEngine {
         }
       });
 
-      // Pass 1: Validate and apply node operations first
-      for (const { operation, index } of nodeOperations) {
-        const error = this.validateOperation(workflowCopy, operation);
-        if (error) {
-          return {
-            success: false,
-            errors: [{
+      const allOperations = [...nodeOperations, ...otherOperations];
+      const errors: WorkflowDiffValidationError[] = [];
+      const appliedIndices: number[] = [];
+      const failedIndices: number[] = [];
+
+      // Process based on mode
+      if (request.continueOnError) {
+        // Best-effort mode: continue even if some operations fail
+        for (const { operation, index } of allOperations) {
+          const error = this.validateOperation(workflowCopy, operation);
+          if (error) {
+            errors.push({
               operation: index,
               message: error,
               details: operation
-            }]
-          };
-        }
-        
-        // Always apply to working copy for proper validation of subsequent operations
-        try {
-          this.applyOperation(workflowCopy, operation);
-        } catch (error) {
-          return {
-            success: false,
-            errors: [{
-              operation: index,
-              message: `Failed to apply operation: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              details: operation
-            }]
-          };
-        }
-      }
+            });
+            failedIndices.push(index);
+            continue;
+          }
 
-      // Pass 2: Validate and apply other operations (connections, metadata)
-      for (const { operation, index } of otherOperations) {
-        const error = this.validateOperation(workflowCopy, operation);
-        if (error) {
-          return {
-            success: false,
-            errors: [{
+          try {
+            this.applyOperation(workflowCopy, operation);
+            appliedIndices.push(index);
+          } catch (error) {
+            const errorMsg = `Failed to apply operation: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            errors.push({
               operation: index,
-              message: error,
+              message: errorMsg,
               details: operation
-            }]
-          };
+            });
+            failedIndices.push(index);
+          }
         }
-        
-        // Always apply to working copy for proper validation of subsequent operations
-        try {
-          this.applyOperation(workflowCopy, operation);
-        } catch (error) {
-          return {
-            success: false,
-            errors: [{
-              operation: index,
-              message: `Failed to apply operation: ${error instanceof Error ? error.message : 'Unknown error'}`,
-              details: operation
-            }]
-          };
-        }
-      }
 
-      // If validateOnly flag is set, return success without applying
-      if (request.validateOnly) {
+        // If validateOnly flag is set, return success without applying
+        if (request.validateOnly) {
+          return {
+            success: errors.length === 0,
+            message: errors.length === 0
+              ? 'Validation successful. All operations are valid.'
+              : `Validation completed with ${errors.length} errors.`,
+            errors: errors.length > 0 ? errors : undefined,
+            applied: appliedIndices,
+            failed: failedIndices
+          };
+        }
+
+        const success = appliedIndices.length > 0;
+        return {
+          success,
+          workflow: workflowCopy,
+          operationsApplied: appliedIndices.length,
+          message: `Applied ${appliedIndices.length} operations, ${failedIndices.length} failed (continueOnError mode)`,
+          errors: errors.length > 0 ? errors : undefined,
+          applied: appliedIndices,
+          failed: failedIndices
+        };
+      } else {
+        // Atomic mode: all operations must succeed
+        // Pass 1: Validate and apply node operations first
+        for (const { operation, index } of nodeOperations) {
+          const error = this.validateOperation(workflowCopy, operation);
+          if (error) {
+            return {
+              success: false,
+              errors: [{
+                operation: index,
+                message: error,
+                details: operation
+              }]
+            };
+          }
+
+          try {
+            this.applyOperation(workflowCopy, operation);
+          } catch (error) {
+            return {
+              success: false,
+              errors: [{
+                operation: index,
+                message: `Failed to apply operation: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                details: operation
+              }]
+            };
+          }
+        }
+
+        // Pass 2: Validate and apply other operations (connections, metadata)
+        for (const { operation, index } of otherOperations) {
+          const error = this.validateOperation(workflowCopy, operation);
+          if (error) {
+            return {
+              success: false,
+              errors: [{
+                operation: index,
+                message: error,
+                details: operation
+              }]
+            };
+          }
+
+          try {
+            this.applyOperation(workflowCopy, operation);
+          } catch (error) {
+            return {
+              success: false,
+              errors: [{
+                operation: index,
+                message: `Failed to apply operation: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                details: operation
+              }]
+            };
+          }
+        }
+
+        // If validateOnly flag is set, return success without applying
+        if (request.validateOnly) {
+          return {
+            success: true,
+            message: 'Validation successful. Operations are valid but not applied.'
+          };
+        }
+
+        const operationsApplied = request.operations.length;
         return {
           success: true,
-          message: 'Validation successful. Operations are valid but not applied.'
+          workflow: workflowCopy,
+          operationsApplied,
+          message: `Successfully applied ${operationsApplied} operations (${nodeOperations.length} node ops, ${otherOperations.length} other ops)`
         };
       }
-
-      const operationsApplied = request.operations.length;
-      return {
-        success: true,
-        workflow: workflowCopy,
-        operationsApplied,
-        message: `Successfully applied ${operationsApplied} operations (${nodeOperations.length} node ops, ${otherOperations.length} other ops)`
-      };
     } catch (error) {
       logger.error('Failed to apply diff', error);
       return {
@@ -181,6 +230,10 @@ export class WorkflowDiffEngine {
       case 'addTag':
       case 'removeTag':
         return null; // These are always valid
+      case 'cleanStaleConnections':
+        return this.validateCleanStaleConnections(workflow, operation);
+      case 'replaceConnections':
+        return this.validateReplaceConnections(workflow, operation);
       default:
         return `Unknown operation type: ${(operation as any).type}`;
     }
@@ -230,6 +283,12 @@ export class WorkflowDiffEngine {
       case 'removeTag':
         this.applyRemoveTag(workflow, operation);
         break;
+      case 'cleanStaleConnections':
+        this.applyCleanStaleConnections(workflow, operation);
+        break;
+      case 'replaceConnections':
+        this.applyReplaceConnections(workflow, operation);
+        break;
     }
   }
 
@@ -303,16 +362,36 @@ export class WorkflowDiffEngine {
 
   // Connection operation validators
   private validateAddConnection(workflow: Workflow, operation: AddConnectionOperation): string | null {
+    // Check for common parameter mistakes (Issue #249)
+    const operationAny = operation as any;
+    if (operationAny.sourceNodeId || operationAny.targetNodeId) {
+      const wrongParams: string[] = [];
+      if (operationAny.sourceNodeId) wrongParams.push('sourceNodeId');
+      if (operationAny.targetNodeId) wrongParams.push('targetNodeId');
+
+      return `Invalid parameter(s): ${wrongParams.join(', ')}. Use 'source' and 'target' instead. Example: {type: "addConnection", source: "Node Name", target: "Target Name"}`;
+    }
+
+    // Check for missing required parameters
+    if (!operation.source) {
+      return `Missing required parameter 'source'. The addConnection operation requires both 'source' and 'target' parameters. Check that you're using 'source' (not 'sourceNodeId').`;
+    }
+    if (!operation.target) {
+      return `Missing required parameter 'target'. The addConnection operation requires both 'source' and 'target' parameters. Check that you're using 'target' (not 'targetNodeId').`;
+    }
+
     const sourceNode = this.findNode(workflow, operation.source, operation.source);
     const targetNode = this.findNode(workflow, operation.target, operation.target);
-    
+
     if (!sourceNode) {
-      return `Source node not found: ${operation.source}`;
+      const availableNodes = workflow.nodes.map(n => n.name).join(', ');
+      return `Source node not found: "${operation.source}". Available nodes: ${availableNodes}`;
     }
     if (!targetNode) {
-      return `Target node not found: ${operation.target}`;
+      const availableNodes = workflow.nodes.map(n => n.name).join(', ');
+      return `Target node not found: "${operation.target}". Available nodes: ${availableNodes}`;
     }
-    
+
     // Check if connection already exists
     const sourceOutput = operation.sourceOutput || 'main';
     const existing = workflow.connections[sourceNode.name]?.[sourceOutput];
@@ -324,35 +403,40 @@ export class WorkflowDiffEngine {
         return `Connection already exists from "${sourceNode.name}" to "${targetNode.name}"`;
       }
     }
-    
+
     return null;
   }
 
   private validateRemoveConnection(workflow: Workflow, operation: RemoveConnectionOperation): string | null {
+    // If ignoreErrors is true, don't validate - operation will silently succeed even if connection doesn't exist
+    if (operation.ignoreErrors) {
+      return null;
+    }
+
     const sourceNode = this.findNode(workflow, operation.source, operation.source);
     const targetNode = this.findNode(workflow, operation.target, operation.target);
-    
+
     if (!sourceNode) {
       return `Source node not found: ${operation.source}`;
     }
     if (!targetNode) {
       return `Target node not found: ${operation.target}`;
     }
-    
+
     const sourceOutput = operation.sourceOutput || 'main';
     const connections = workflow.connections[sourceNode.name]?.[sourceOutput];
     if (!connections) {
       return `No connections found from "${sourceNode.name}"`;
     }
-    
+
     const hasConnection = connections.some(conns =>
       conns.some(c => c.node === targetNode.name)
     );
-    
+
     if (!hasConnection) {
       return `No connection exists from "${sourceNode.name}" to "${targetNode.name}"`;
     }
-    
+
     return null;
   }
 
@@ -515,7 +599,13 @@ export class WorkflowDiffEngine {
   private applyRemoveConnection(workflow: Workflow, operation: RemoveConnectionOperation): void {
     const sourceNode = this.findNode(workflow, operation.source, operation.source);
     const targetNode = this.findNode(workflow, operation.target, operation.target);
-    if (!sourceNode || !targetNode) return;
+    // If ignoreErrors is true, silently succeed even if nodes don't exist
+    if (!sourceNode || !targetNode) {
+      if (operation.ignoreErrors) {
+        return; // Gracefully handle missing nodes
+      }
+      return; // Should never reach here if validation passed, but safety check
+    }
     
     const sourceOutput = operation.sourceOutput || 'main';
     const connections = workflow.connections[sourceNode.name]?.[sourceOutput];
@@ -590,6 +680,116 @@ export class WorkflowDiffEngine {
     }
   }
 
+  // Connection cleanup operation validators
+  private validateCleanStaleConnections(workflow: Workflow, operation: CleanStaleConnectionsOperation): string | null {
+    // This operation is always valid - it just cleans up what it finds
+    return null;
+  }
+
+  private validateReplaceConnections(workflow: Workflow, operation: ReplaceConnectionsOperation): string | null {
+    // Validate that all referenced nodes exist
+    const nodeNames = new Set(workflow.nodes.map(n => n.name));
+
+    for (const [sourceName, outputs] of Object.entries(operation.connections)) {
+      if (!nodeNames.has(sourceName)) {
+        return `Source node not found in connections: ${sourceName}`;
+      }
+
+      // outputs is the value from Object.entries, need to iterate its keys
+      for (const outputName of Object.keys(outputs)) {
+        const connections = outputs[outputName];
+        for (const conns of connections) {
+          for (const conn of conns) {
+            if (!nodeNames.has(conn.node)) {
+              return `Target node not found in connections: ${conn.node}`;
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // Connection cleanup operation appliers
+  private applyCleanStaleConnections(workflow: Workflow, operation: CleanStaleConnectionsOperation): void {
+    const nodeNames = new Set(workflow.nodes.map(n => n.name));
+    const staleConnections: Array<{ from: string; to: string }> = [];
+
+    // If dryRun, only identify stale connections without removing them
+    if (operation.dryRun) {
+      for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
+        if (!nodeNames.has(sourceName)) {
+          for (const [outputName, connections] of Object.entries(outputs)) {
+            for (const conns of connections) {
+              for (const conn of conns) {
+                staleConnections.push({ from: sourceName, to: conn.node });
+              }
+            }
+          }
+        } else {
+          for (const [outputName, connections] of Object.entries(outputs)) {
+            for (const conns of connections) {
+              for (const conn of conns) {
+                if (!nodeNames.has(conn.node)) {
+                  staleConnections.push({ from: sourceName, to: conn.node });
+                }
+              }
+            }
+          }
+        }
+      }
+      logger.info(`[DryRun] Would remove ${staleConnections.length} stale connections:`, staleConnections);
+      return;
+    }
+
+    // Actually remove stale connections
+    for (const [sourceName, outputs] of Object.entries(workflow.connections)) {
+      // If source node doesn't exist, mark all connections as stale
+      if (!nodeNames.has(sourceName)) {
+        for (const [outputName, connections] of Object.entries(outputs)) {
+          for (const conns of connections) {
+            for (const conn of conns) {
+              staleConnections.push({ from: sourceName, to: conn.node });
+            }
+          }
+        }
+        delete workflow.connections[sourceName];
+        continue;
+      }
+
+      // Check each connection
+      for (const [outputName, connections] of Object.entries(outputs)) {
+        const filteredConnections = connections.map(conns =>
+          conns.filter(conn => {
+            if (!nodeNames.has(conn.node)) {
+              staleConnections.push({ from: sourceName, to: conn.node });
+              return false;
+            }
+            return true;
+          })
+        ).filter(conns => conns.length > 0);
+
+        if (filteredConnections.length === 0) {
+          delete outputs[outputName];
+        } else {
+          outputs[outputName] = filteredConnections;
+        }
+      }
+
+      // Clean up empty output objects
+      if (Object.keys(outputs).length === 0) {
+        delete workflow.connections[sourceName];
+      }
+    }
+
+    logger.info(`Removed ${staleConnections.length} stale connections`);
+  }
+
+  private applyReplaceConnections(workflow: Workflow, operation: ReplaceConnectionsOperation): void {
+    workflow.connections = operation.connections;
+  }
+
   // Helper methods
   private findNode(workflow: Workflow, nodeId?: string, nodeName?: string): WorkflowNode | null {
     if (nodeId) {

src/services/workflow-validator.ts

@@ -7,6 +7,8 @@ import { NodeRepository } from '../database/node-repository';
 import { EnhancedConfigValidator } from './enhanced-config-validator';
 import { ExpressionValidator } from './expression-validator';
 import { ExpressionFormatValidator } from './expression-format-validator';
+import { NodeSimilarityService, NodeSuggestion } from './node-similarity-service';
+import { NodeTypeNormalizer } from '../utils/node-type-normalizer';
 import { Logger } from '../utils/logger';
 const logger = new Logger({ prefix: '[WorkflowValidator]' });
 
@@ -73,11 +75,14 @@ export interface WorkflowValidationResult {
 
 export class WorkflowValidator {
   private currentWorkflow: WorkflowJson | null = null;
+  private similarityService: NodeSimilarityService;
 
   constructor(
     private nodeRepository: NodeRepository,
     private nodeValidator: typeof EnhancedConfigValidator
-  ) {}
+  ) {
+    this.similarityService = new NodeSimilarityService(nodeRepository);
+  }
 
   /**
    * Check if a node is a Sticky Note or other non-executable node
@@ -242,8 +247,8 @@ export class WorkflowValidator {
     // Check for minimum viable workflow
     if (workflow.nodes.length === 1) {
       const singleNode = workflow.nodes[0];
-      const normalizedType = singleNode.type.replace('n8n-nodes-base.', 'nodes-base.');
-      const isWebhook = normalizedType === 'nodes-base.webhook' || 
+      const normalizedType = NodeTypeNormalizer.normalizeToFullForm(singleNode.type);
+      const isWebhook = normalizedType === 'nodes-base.webhook' ||
                        normalizedType === 'nodes-base.webhookTrigger';
       
       if (!isWebhook) {
@@ -299,8 +304,8 @@ export class WorkflowValidator {
 
     // Count trigger nodes - normalize type names first
     const triggerNodes = workflow.nodes.filter(n => {
-      const normalizedType = n.type.replace('n8n-nodes-base.', 'nodes-base.');
-      return normalizedType.toLowerCase().includes('trigger') || 
+      const normalizedType = NodeTypeNormalizer.normalizeToFullForm(n.type);
+      return normalizedType.toLowerCase().includes('trigger') ||
              normalizedType.toLowerCase().includes('webhook') ||
              normalizedType === 'nodes-base.start' ||
              normalizedType === 'nodes-base.manualTrigger' ||
@@ -359,78 +364,57 @@ export class WorkflowValidator {
             });
           }
         }
-        // FIRST: Check for common invalid patterns before database lookup
-        if (node.type.startsWith('nodes-base.')) {
-          // This is ALWAYS invalid in workflows - must use n8n-nodes-base prefix
-          const correctType = node.type.replace('nodes-base.', 'n8n-nodes-base.');
-          result.errors.push({
+        // Normalize node type FIRST to ensure consistent lookup
+        const normalizedType = NodeTypeNormalizer.normalizeToFullForm(node.type);
+
+        // Update node type in place if it was normalized
+        if (normalizedType !== node.type) {
+          node.type = normalizedType;
+        }
+
+        // Get node definition using normalized type
+        const nodeInfo = this.nodeRepository.getNode(normalizedType);
+
+        if (!nodeInfo) {
+          // Use NodeSimilarityService to find suggestions
+          const suggestions = await this.similarityService.findSimilarNodes(node.type, 3);
+
+          let message = `Unknown node type: "${node.type}".`;
+
+          if (suggestions.length > 0) {
+            message += '\n\nDid you mean one of these?';
+            for (const suggestion of suggestions) {
+              const confidence = Math.round(suggestion.confidence * 100);
+              message += `\n• ${suggestion.nodeType} (${confidence}% match)`;
+              if (suggestion.displayName) {
+                message += ` - ${suggestion.displayName}`;
+              }
+              message += `\n  → ${suggestion.reason}`;
+              if (suggestion.confidence >= 0.9) {
+                message += ' (can be auto-fixed)';
+              }
+            }
+          } else {
+            message += ' No similar nodes found. Node types must include the package prefix (e.g., "n8n-nodes-base.webhook").';
+          }
+
+          const error: any = {
             type: 'error',
             nodeId: node.id,
             nodeName: node.name,
-            message: `Invalid node type: "${node.type}". Use "${correctType}" instead. Node types in workflows must use the full package name.`
-          });
-          continue;
-        }
-        
-        // Get node definition - try multiple formats
-        let nodeInfo = this.nodeRepository.getNode(node.type);
-        
-        // If not found, try with normalized type
-        if (!nodeInfo) {
-          let normalizedType = node.type;
-          
-          // Handle n8n-nodes-base -> nodes-base
-          if (node.type.startsWith('n8n-nodes-base.')) {
-            normalizedType = node.type.replace('n8n-nodes-base.', 'nodes-base.');
-            nodeInfo = this.nodeRepository.getNode(normalizedType);
+            message
+          };
+
+          // Add suggestions as metadata for programmatic access
+          if (suggestions.length > 0) {
+            error.suggestions = suggestions.map(s => ({
+              nodeType: s.nodeType,
+              confidence: s.confidence,
+              reason: s.reason
+            }));
           }
-          // Handle @n8n/n8n-nodes-langchain -> nodes-langchain
-          else if (node.type.startsWith('@n8n/n8n-nodes-langchain.')) {
-            normalizedType = node.type.replace('@n8n/n8n-nodes-langchain.', 'nodes-langchain.');
-            nodeInfo = this.nodeRepository.getNode(normalizedType);
-          }
-        }
-        
-        if (!nodeInfo) {
-          // Check for common mistakes
-          let suggestion = '';
-          
-          // Missing package prefix
-          if (node.type.startsWith('nodes-base.')) {
-            const withPrefix = node.type.replace('nodes-base.', 'n8n-nodes-base.');
-            const exists = this.nodeRepository.getNode(withPrefix) || 
-                          this.nodeRepository.getNode(withPrefix.replace('n8n-nodes-base.', 'nodes-base.'));
-            if (exists) {
-              suggestion = ` Did you mean "n8n-nodes-base.${node.type.substring(11)}"?`;
-            }
-          }
-          // Check if it's just the node name without package
-          else if (!node.type.includes('.')) {
-            // Try common node names
-            const commonNodes = [
-              'webhook', 'httpRequest', 'set', 'code', 'manualTrigger', 
-              'scheduleTrigger', 'emailSend', 'slack', 'discord'
-            ];
-            
-            if (commonNodes.includes(node.type)) {
-              suggestion = ` Did you mean "n8n-nodes-base.${node.type}"?`;
-            }
-          }
-          
-          // If no specific suggestion, try to find similar nodes
-          if (!suggestion) {
-            const similarNodes = this.findSimilarNodeTypes(node.type);
-            if (similarNodes.length > 0) {
-              suggestion = ` Did you mean: ${similarNodes.map(n => `"${n}"`).join(', ')}?`;
-            }
-          }
-          
-          result.errors.push({
-            type: 'error',
-            nodeId: node.id,
-            nodeName: node.name,
-            message: `Unknown node type: "${node.type}".${suggestion} Node types must include the package prefix (e.g., "n8n-nodes-base.webhook", not "webhook" or "nodes-base.webhook").`
-          });
+
+          result.errors.push(error);
           continue;
         }
 
@@ -613,9 +597,9 @@ export class WorkflowValidator {
     // Check for orphaned nodes (exclude sticky notes)
     for (const node of workflow.nodes) {
       if (node.disabled || this.isStickyNote(node)) continue;
-      
-      const normalizedType = node.type.replace('n8n-nodes-base.', 'nodes-base.');
-      const isTrigger = normalizedType.toLowerCase().includes('trigger') || 
+
+      const normalizedType = NodeTypeNormalizer.normalizeToFullForm(node.type);
+      const isTrigger = normalizedType.toLowerCase().includes('trigger') ||
                        normalizedType.toLowerCase().includes('webhook') ||
                        normalizedType === 'nodes-base.start' ||
                        normalizedType === 'nodes-base.manualTrigger' ||
@@ -674,7 +658,7 @@ export class WorkflowValidator {
         }
 
         // Special validation for SplitInBatches node
-        if (sourceNode && sourceNode.type === 'n8n-nodes-base.splitInBatches') {
+        if (sourceNode && sourceNode.type === 'nodes-base.splitInBatches') {
           this.validateSplitInBatchesConnection(
             sourceNode,
             outputIndex,
@@ -687,7 +671,7 @@ export class WorkflowValidator {
         // Check for self-referencing connections
         if (connection.node === sourceName) {
           // This is only a warning for non-loop nodes
-          if (sourceNode && sourceNode.type !== 'n8n-nodes-base.splitInBatches') {
+          if (sourceNode && sourceNode.type !== 'nodes-base.splitInBatches') {
             result.warnings.push({
               type: 'warning',
               message: `Node "${sourceName}" has a self-referencing connection. This can cause infinite loops.`
@@ -827,22 +811,12 @@ export class WorkflowValidator {
     // The source should be an AI Agent connecting to this target node as a tool
     
     // Get target node info to check if it can be used as a tool
-    let targetNodeInfo = this.nodeRepository.getNode(targetNode.type);
-    
-    // Try normalized type if not found
-    if (!targetNodeInfo) {
-      let normalizedType = targetNode.type;
-      
-      // Handle n8n-nodes-base -> nodes-base
-      if (targetNode.type.startsWith('n8n-nodes-base.')) {
-        normalizedType = targetNode.type.replace('n8n-nodes-base.', 'nodes-base.');
-        targetNodeInfo = this.nodeRepository.getNode(normalizedType);
-      }
-      // Handle @n8n/n8n-nodes-langchain -> nodes-langchain
-      else if (targetNode.type.startsWith('@n8n/n8n-nodes-langchain.')) {
-        normalizedType = targetNode.type.replace('@n8n/n8n-nodes-langchain.', 'nodes-langchain.');
-        targetNodeInfo = this.nodeRepository.getNode(normalizedType);
-      }
+    const normalizedType = NodeTypeNormalizer.normalizeToFullForm(targetNode.type);
+    let targetNodeInfo = this.nodeRepository.getNode(normalizedType);
+
+    // Try original type if normalization didn't help (fallback for edge cases)
+    if (!targetNodeInfo && normalizedType !== targetNode.type) {
+      targetNodeInfo = this.nodeRepository.getNode(targetNode.type);
     }
     
     if (targetNodeInfo && !targetNodeInfo.isAITool && targetNodeInfo.package !== 'n8n-nodes-base') {
@@ -1205,65 +1179,6 @@ export class WorkflowValidator {
     return maxChain;
   }
 
-  /**
-   * Find similar node types for suggestions
-   */
-  private findSimilarNodeTypes(invalidType: string): string[] {
-    // Since we don't have a method to list all nodes, we'll use a predefined list
-    // of common node types that users might be looking for
-    const suggestions: string[] = [];
-    const nodeName = invalidType.includes('.') ? invalidType.split('.').pop()! : invalidType;
-    
-    const commonNodeMappings: Record<string, string[]> = {
-      'webhook': ['nodes-base.webhook'],
-      'httpRequest': ['nodes-base.httpRequest'],
-      'http': ['nodes-base.httpRequest'],
-      'set': ['nodes-base.set'],
-      'code': ['nodes-base.code'],
-      'manualTrigger': ['nodes-base.manualTrigger'],
-      'manual': ['nodes-base.manualTrigger'],
-      'scheduleTrigger': ['nodes-base.scheduleTrigger'],
-      'schedule': ['nodes-base.scheduleTrigger'],
-      'cron': ['nodes-base.scheduleTrigger'],
-      'emailSend': ['nodes-base.emailSend'],
-      'email': ['nodes-base.emailSend'],
-      'slack': ['nodes-base.slack'],
-      'discord': ['nodes-base.discord'],
-      'postgres': ['nodes-base.postgres'],
-      'mysql': ['nodes-base.mySql'],
-      'mongodb': ['nodes-base.mongoDb'],
-      'redis': ['nodes-base.redis'],
-      'if': ['nodes-base.if'],
-      'switch': ['nodes-base.switch'],
-      'merge': ['nodes-base.merge'],
-      'splitInBatches': ['nodes-base.splitInBatches'],
-      'loop': ['nodes-base.splitInBatches'],
-      'googleSheets': ['nodes-base.googleSheets'],
-      'sheets': ['nodes-base.googleSheets'],
-      'airtable': ['nodes-base.airtable'],
-      'github': ['nodes-base.github'],
-      'git': ['nodes-base.github'],
-    };
-    
-    // Check for exact match
-    const lowerNodeName = nodeName.toLowerCase();
-    if (commonNodeMappings[lowerNodeName]) {
-      suggestions.push(...commonNodeMappings[lowerNodeName]);
-    }
-    
-    // Check for partial matches
-    Object.entries(commonNodeMappings).forEach(([key, values]) => {
-      if (key.includes(lowerNodeName) || lowerNodeName.includes(key)) {
-        values.forEach(v => {
-          if (!suggestions.includes(v)) {
-            suggestions.push(v);
-          }
-        });
-      }
-    });
-    
-    return suggestions.slice(0, 3); // Return top 3 suggestions
-  }
 
   /**
    * Generate suggestions based on validation results

src/telemetry/batch-processor.ts

@@ -0,0 +1,400 @@
+/**
+ * Batch Processor for Telemetry
+ * Handles batching, queuing, and sending telemetry data to Supabase
+ */
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import { TelemetryEvent, WorkflowTelemetry, TELEMETRY_CONFIG, TelemetryMetrics } from './telemetry-types';
+import { TelemetryError, TelemetryErrorType, TelemetryCircuitBreaker } from './telemetry-error';
+import { logger } from '../utils/logger';
+
+export class TelemetryBatchProcessor {
+  private flushTimer?: NodeJS.Timeout;
+  private isFlushingEvents: boolean = false;
+  private isFlushingWorkflows: boolean = false;
+  private circuitBreaker: TelemetryCircuitBreaker;
+  private metrics: TelemetryMetrics = {
+    eventsTracked: 0,
+    eventsDropped: 0,
+    eventsFailed: 0,
+    batchesSent: 0,
+    batchesFailed: 0,
+    averageFlushTime: 0,
+    rateLimitHits: 0
+  };
+  private flushTimes: number[] = [];
+  private deadLetterQueue: (TelemetryEvent | WorkflowTelemetry)[] = [];
+  private readonly maxDeadLetterSize = 100;
+
+  constructor(
+    private supabase: SupabaseClient | null,
+    private isEnabled: () => boolean
+  ) {
+    this.circuitBreaker = new TelemetryCircuitBreaker();
+  }
+
+  /**
+   * Start the batch processor
+   */
+  start(): void {
+    if (!this.isEnabled() || !this.supabase) return;
+
+    // Set up periodic flushing
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, TELEMETRY_CONFIG.BATCH_FLUSH_INTERVAL);
+
+    // Prevent timer from keeping process alive
+    // In tests, flushTimer might be a number instead of a Timer object
+    if (typeof this.flushTimer === 'object' && 'unref' in this.flushTimer) {
+      this.flushTimer.unref();
+    }
+
+    // Set up process exit handlers
+    process.on('beforeExit', () => this.flush());
+    process.on('SIGINT', () => {
+      this.flush();
+      process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+      this.flush();
+      process.exit(0);
+    });
+
+    logger.debug('Telemetry batch processor started');
+  }
+
+  /**
+   * Stop the batch processor
+   */
+  stop(): void {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+    logger.debug('Telemetry batch processor stopped');
+  }
+
+  /**
+   * Flush events and workflows to Supabase
+   */
+  async flush(events?: TelemetryEvent[], workflows?: WorkflowTelemetry[]): Promise<void> {
+    if (!this.isEnabled() || !this.supabase) return;
+
+    // Check circuit breaker
+    if (!this.circuitBreaker.shouldAllow()) {
+      logger.debug('Circuit breaker open - skipping flush');
+      this.metrics.eventsDropped += (events?.length || 0) + (workflows?.length || 0);
+      return;
+    }
+
+    const startTime = Date.now();
+    let hasErrors = false;
+
+    // Flush events if provided
+    if (events && events.length > 0) {
+      hasErrors = !(await this.flushEvents(events)) || hasErrors;
+    }
+
+    // Flush workflows if provided
+    if (workflows && workflows.length > 0) {
+      hasErrors = !(await this.flushWorkflows(workflows)) || hasErrors;
+    }
+
+    // Record flush time
+    const flushTime = Date.now() - startTime;
+    this.recordFlushTime(flushTime);
+
+    // Update circuit breaker
+    if (hasErrors) {
+      this.circuitBreaker.recordFailure();
+    } else {
+      this.circuitBreaker.recordSuccess();
+    }
+
+    // Process dead letter queue if circuit is healthy
+    if (!hasErrors && this.deadLetterQueue.length > 0) {
+      await this.processDeadLetterQueue();
+    }
+  }
+
+  /**
+   * Flush events with batching
+   */
+  private async flushEvents(events: TelemetryEvent[]): Promise<boolean> {
+    if (this.isFlushingEvents || events.length === 0) return true;
+
+    this.isFlushingEvents = true;
+
+    try {
+      // Batch events
+      const batches = this.createBatches(events, TELEMETRY_CONFIG.MAX_BATCH_SIZE);
+
+      for (const batch of batches) {
+        const result = await this.executeWithRetry(async () => {
+          const { error } = await this.supabase!
+            .from('telemetry_events')
+            .insert(batch);
+
+          if (error) {
+            throw error;
+          }
+
+          logger.debug(`Flushed batch of ${batch.length} telemetry events`);
+          return true;
+        }, 'Flush telemetry events');
+
+        if (result) {
+          this.metrics.eventsTracked += batch.length;
+          this.metrics.batchesSent++;
+        } else {
+          this.metrics.eventsFailed += batch.length;
+          this.metrics.batchesFailed++;
+          this.addToDeadLetterQueue(batch);
+          return false;
+        }
+      }
+
+      return true;
+    } catch (error) {
+      logger.debug('Failed to flush events:', error);
+      throw new TelemetryError(
+        TelemetryErrorType.NETWORK_ERROR,
+        'Failed to flush events',
+        { error: error instanceof Error ? error.message : String(error) },
+        true
+      );
+    } finally {
+      this.isFlushingEvents = false;
+    }
+  }
+
+  /**
+   * Flush workflows with deduplication
+   */
+  private async flushWorkflows(workflows: WorkflowTelemetry[]): Promise<boolean> {
+    if (this.isFlushingWorkflows || workflows.length === 0) return true;
+
+    this.isFlushingWorkflows = true;
+
+    try {
+      // Deduplicate workflows by hash
+      const uniqueWorkflows = this.deduplicateWorkflows(workflows);
+      logger.debug(`Deduplicating workflows: ${workflows.length} -> ${uniqueWorkflows.length}`);
+
+      // Batch workflows
+      const batches = this.createBatches(uniqueWorkflows, TELEMETRY_CONFIG.MAX_BATCH_SIZE);
+
+      for (const batch of batches) {
+        const result = await this.executeWithRetry(async () => {
+          const { error } = await this.supabase!
+            .from('telemetry_workflows')
+            .insert(batch);
+
+          if (error) {
+            throw error;
+          }
+
+          logger.debug(`Flushed batch of ${batch.length} telemetry workflows`);
+          return true;
+        }, 'Flush telemetry workflows');
+
+        if (result) {
+          this.metrics.eventsTracked += batch.length;
+          this.metrics.batchesSent++;
+        } else {
+          this.metrics.eventsFailed += batch.length;
+          this.metrics.batchesFailed++;
+          this.addToDeadLetterQueue(batch);
+          return false;
+        }
+      }
+
+      return true;
+    } catch (error) {
+      logger.debug('Failed to flush workflows:', error);
+      throw new TelemetryError(
+        TelemetryErrorType.NETWORK_ERROR,
+        'Failed to flush workflows',
+        { error: error instanceof Error ? error.message : String(error) },
+        true
+      );
+    } finally {
+      this.isFlushingWorkflows = false;
+    }
+  }
+
+  /**
+   * Execute operation with exponential backoff retry
+   */
+  private async executeWithRetry<T>(
+    operation: () => Promise<T>,
+    operationName: string
+  ): Promise<T | null> {
+    let lastError: Error | null = null;
+    let delay = TELEMETRY_CONFIG.RETRY_DELAY;
+
+    for (let attempt = 1; attempt <= TELEMETRY_CONFIG.MAX_RETRIES; attempt++) {
+      try {
+        // In test environment, execute without timeout but still handle errors
+        if (process.env.NODE_ENV === 'test' && process.env.VITEST) {
+          const result = await operation();
+          return result;
+        }
+
+        // Create a timeout promise
+        const timeoutPromise = new Promise<never>((_, reject) => {
+          setTimeout(() => reject(new Error('Operation timed out')), TELEMETRY_CONFIG.OPERATION_TIMEOUT);
+        });
+
+        // Race between operation and timeout
+        const result = await Promise.race([operation(), timeoutPromise]) as T;
+        return result;
+      } catch (error) {
+        lastError = error as Error;
+        logger.debug(`${operationName} attempt ${attempt} failed:`, error);
+
+        if (attempt < TELEMETRY_CONFIG.MAX_RETRIES) {
+          // Skip delay in test environment when using fake timers
+          if (!(process.env.NODE_ENV === 'test' && process.env.VITEST)) {
+            // Exponential backoff with jitter
+            const jitter = Math.random() * 0.3 * delay; // 30% jitter
+            const waitTime = delay + jitter;
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+            delay *= 2; // Double the delay for next attempt
+          }
+          // In test mode, continue to next retry attempt without delay
+        }
+      }
+    }
+
+    logger.debug(`${operationName} failed after ${TELEMETRY_CONFIG.MAX_RETRIES} attempts:`, lastError);
+    return null;
+  }
+
+  /**
+   * Create batches from array
+   */
+  private createBatches<T>(items: T[], batchSize: number): T[][] {
+    const batches: T[][] = [];
+
+    for (let i = 0; i < items.length; i += batchSize) {
+      batches.push(items.slice(i, i + batchSize));
+    }
+
+    return batches;
+  }
+
+  /**
+   * Deduplicate workflows by hash
+   */
+  private deduplicateWorkflows(workflows: WorkflowTelemetry[]): WorkflowTelemetry[] {
+    const seen = new Set<string>();
+    const unique: WorkflowTelemetry[] = [];
+
+    for (const workflow of workflows) {
+      if (!seen.has(workflow.workflow_hash)) {
+        seen.add(workflow.workflow_hash);
+        unique.push(workflow);
+      }
+    }
+
+    return unique;
+  }
+
+  /**
+   * Add failed items to dead letter queue
+   */
+  private addToDeadLetterQueue(items: (TelemetryEvent | WorkflowTelemetry)[]): void {
+    for (const item of items) {
+      this.deadLetterQueue.push(item);
+
+      // Maintain max size
+      if (this.deadLetterQueue.length > this.maxDeadLetterSize) {
+        const dropped = this.deadLetterQueue.shift();
+        if (dropped) {
+          this.metrics.eventsDropped++;
+        }
+      }
+    }
+
+    logger.debug(`Added ${items.length} items to dead letter queue`);
+  }
+
+  /**
+   * Process dead letter queue when circuit is healthy
+   */
+  private async processDeadLetterQueue(): Promise<void> {
+    if (this.deadLetterQueue.length === 0) return;
+
+    logger.debug(`Processing ${this.deadLetterQueue.length} items from dead letter queue`);
+
+    const events: TelemetryEvent[] = [];
+    const workflows: WorkflowTelemetry[] = [];
+
+    // Separate events and workflows
+    for (const item of this.deadLetterQueue) {
+      if ('workflow_hash' in item) {
+        workflows.push(item as WorkflowTelemetry);
+      } else {
+        events.push(item as TelemetryEvent);
+      }
+    }
+
+    // Clear dead letter queue
+    this.deadLetterQueue = [];
+
+    // Try to flush
+    if (events.length > 0) {
+      await this.flushEvents(events);
+    }
+    if (workflows.length > 0) {
+      await this.flushWorkflows(workflows);
+    }
+  }
+
+  /**
+   * Record flush time for metrics
+   */
+  private recordFlushTime(time: number): void {
+    this.flushTimes.push(time);
+
+    // Keep last 100 flush times
+    if (this.flushTimes.length > 100) {
+      this.flushTimes.shift();
+    }
+
+    // Update average
+    const sum = this.flushTimes.reduce((a, b) => a + b, 0);
+    this.metrics.averageFlushTime = Math.round(sum / this.flushTimes.length);
+    this.metrics.lastFlushTime = time;
+  }
+
+  /**
+   * Get processor metrics
+   */
+  getMetrics(): TelemetryMetrics & { circuitBreakerState: any; deadLetterQueueSize: number } {
+    return {
+      ...this.metrics,
+      circuitBreakerState: this.circuitBreaker.getState(),
+      deadLetterQueueSize: this.deadLetterQueue.length
+    };
+  }
+
+  /**
+   * Reset metrics
+   */
+  resetMetrics(): void {
+    this.metrics = {
+      eventsTracked: 0,
+      eventsDropped: 0,
+      eventsFailed: 0,
+      batchesSent: 0,
+      batchesFailed: 0,
+      averageFlushTime: 0,
+      rateLimitHits: 0
+    };
+    this.flushTimes = [];
+    this.circuitBreaker.reset();
+  }
+}

src/telemetry/config-manager.ts

@@ -0,0 +1,304 @@
+/**
+ * Telemetry Configuration Manager
+ * Handles telemetry settings, opt-in/opt-out, and first-run detection
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+import { hostname, platform, arch } from 'os';
+
+export interface TelemetryConfig {
+  enabled: boolean;
+  userId: string;
+  firstRun?: string;
+  lastModified?: string;
+  version?: string;
+}
+
+export class TelemetryConfigManager {
+  private static instance: TelemetryConfigManager;
+  private readonly configDir: string;
+  private readonly configPath: string;
+  private config: TelemetryConfig | null = null;
+
+  private constructor() {
+    this.configDir = join(homedir(), '.n8n-mcp');
+    this.configPath = join(this.configDir, 'telemetry.json');
+  }
+
+  static getInstance(): TelemetryConfigManager {
+    if (!TelemetryConfigManager.instance) {
+      TelemetryConfigManager.instance = new TelemetryConfigManager();
+    }
+    return TelemetryConfigManager.instance;
+  }
+
+  /**
+   * Generate a deterministic anonymous user ID based on machine characteristics
+   */
+  private generateUserId(): string {
+    const machineId = `${hostname()}-${platform()}-${arch()}-${homedir()}`;
+    return createHash('sha256').update(machineId).digest('hex').substring(0, 16);
+  }
+
+  /**
+   * Load configuration from disk or create default
+   */
+  loadConfig(): TelemetryConfig {
+    if (this.config) {
+      return this.config;
+    }
+
+    if (!existsSync(this.configPath)) {
+      // First run - create default config
+      const version = this.getPackageVersion();
+
+      // Check if telemetry is disabled via environment variable
+      const envDisabled = this.isDisabledByEnvironment();
+
+      this.config = {
+        enabled: !envDisabled, // Respect env var on first run
+        userId: this.generateUserId(),
+        firstRun: new Date().toISOString(),
+        version
+      };
+
+      this.saveConfig();
+
+      // Only show notice if not disabled via environment
+      if (!envDisabled) {
+        this.showFirstRunNotice();
+      }
+
+      return this.config;
+    }
+
+    try {
+      const rawConfig = readFileSync(this.configPath, 'utf-8');
+      this.config = JSON.parse(rawConfig);
+
+      // Ensure userId exists (for upgrades from older versions)
+      if (!this.config!.userId) {
+        this.config!.userId = this.generateUserId();
+        this.saveConfig();
+      }
+
+      return this.config!;
+    } catch (error) {
+      console.error('Failed to load telemetry config, using defaults:', error);
+      this.config = {
+        enabled: false,
+        userId: this.generateUserId()
+      };
+      return this.config;
+    }
+  }
+
+  /**
+   * Save configuration to disk
+   */
+  private saveConfig(): void {
+    if (!this.config) return;
+
+    try {
+      if (!existsSync(this.configDir)) {
+        mkdirSync(this.configDir, { recursive: true });
+      }
+
+      this.config.lastModified = new Date().toISOString();
+      writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    } catch (error) {
+      console.error('Failed to save telemetry config:', error);
+    }
+  }
+
+  /**
+   * Check if telemetry is enabled
+   * Priority: Environment variable > Config file > Default (true)
+   */
+  isEnabled(): boolean {
+    // Check environment variables first (for Docker users)
+    if (this.isDisabledByEnvironment()) {
+      return false;
+    }
+
+    const config = this.loadConfig();
+    return config.enabled;
+  }
+
+  /**
+   * Check if telemetry is disabled via environment variable
+   */
+  private isDisabledByEnvironment(): boolean {
+    const envVars = [
+      'N8N_MCP_TELEMETRY_DISABLED',
+      'TELEMETRY_DISABLED',
+      'DISABLE_TELEMETRY'
+    ];
+
+    for (const varName of envVars) {
+      const value = process.env[varName];
+      if (value !== undefined) {
+        const normalized = value.toLowerCase().trim();
+
+        // Warn about invalid values
+        if (!['true', 'false', '1', '0', ''].includes(normalized)) {
+          console.warn(
+            `⚠️  Invalid telemetry environment variable value: ${varName}="${value}"\n` +
+            `   Use "true" to disable or "false" to enable telemetry.`
+          );
+        }
+
+        // Accept common truthy values
+        if (normalized === 'true' || normalized === '1') {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get the anonymous user ID
+   */
+  getUserId(): string {
+    const config = this.loadConfig();
+    return config.userId;
+  }
+
+  /**
+   * Check if this is the first run
+   */
+  isFirstRun(): boolean {
+    return !existsSync(this.configPath);
+  }
+
+  /**
+   * Enable telemetry
+   */
+  enable(): void {
+    const config = this.loadConfig();
+    config.enabled = true;
+    this.config = config;
+    this.saveConfig();
+    console.log('✓ Anonymous telemetry enabled');
+  }
+
+  /**
+   * Disable telemetry
+   */
+  disable(): void {
+    const config = this.loadConfig();
+    config.enabled = false;
+    this.config = config;
+    this.saveConfig();
+    console.log('✓ Anonymous telemetry disabled');
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus(): string {
+    const config = this.loadConfig();
+
+    // Check if disabled by environment
+    const envDisabled = this.isDisabledByEnvironment();
+
+    let status = config.enabled ? 'ENABLED' : 'DISABLED';
+    if (envDisabled) {
+      status = 'DISABLED (via environment variable)';
+    }
+
+    return `
+Telemetry Status: ${status}
+Anonymous ID: ${config.userId}
+First Run: ${config.firstRun || 'Unknown'}
+Config Path: ${this.configPath}
+
+To opt-out: npx n8n-mcp telemetry disable
+To opt-in:  npx n8n-mcp telemetry enable
+
+For Docker: Set N8N_MCP_TELEMETRY_DISABLED=true
+`;
+  }
+
+  /**
+   * Show first-run notice to user
+   */
+  private showFirstRunNotice(): void {
+    console.log(`
+╔════════════════════════════════════════════════════════════╗
+║              Anonymous Usage Statistics                     ║
+╠════════════════════════════════════════════════════════════╣
+║                                                             ║
+║  n8n-mcp collects anonymous usage data to improve the      ║
+║  tool and understand how it's being used.                  ║
+║                                                             ║
+║  We track:                                                 ║
+║  • Which MCP tools are used (no parameters)                ║
+║  • Workflow structures (sanitized, no sensitive data)      ║
+║  • Error patterns (hashed, no details)                     ║
+║  • Performance metrics (timing, success rates)             ║
+║                                                             ║
+║  We NEVER collect:                                         ║
+║  • URLs, API keys, or credentials                          ║
+║  • Workflow content or actual data                         ║
+║  • Personal or identifiable information                    ║
+║  • n8n instance details or locations                       ║
+║                                                             ║
+║  Your anonymous ID: ${this.config?.userId || 'generating...'}          ║
+║                                                             ║
+║  This helps me understand usage patterns and improve       ║
+║  n8n-mcp for everyone. Thank you for your support!         ║
+║                                                             ║
+║  To opt-out at any time:                                   ║
+║  npx n8n-mcp telemetry disable                            ║
+║                                                             ║
+║  Data deletion requests:                                   ║
+║  Email romuald@n8n-mcp.com with your anonymous ID          ║
+║                                                             ║
+║  Learn more:                                               ║
+║  https://github.com/czlonkowski/n8n-mcp/blob/main/PRIVACY.md ║
+║                                                             ║
+╚════════════════════════════════════════════════════════════╝
+`);
+  }
+
+  /**
+   * Get package version safely
+   */
+  private getPackageVersion(): string {
+    try {
+      // Try multiple approaches to find package.json
+      const possiblePaths = [
+        resolve(__dirname, '..', '..', 'package.json'),
+        resolve(process.cwd(), 'package.json'),
+        resolve(__dirname, '..', '..', '..', 'package.json')
+      ];
+
+      for (const packagePath of possiblePaths) {
+        if (existsSync(packagePath)) {
+          const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+          if (packageJson.version) {
+            return packageJson.version;
+          }
+        }
+      }
+
+      // Fallback: try require (works in some environments)
+      try {
+        const packageJson = require('../../package.json');
+        return packageJson.version || 'unknown';
+      } catch {
+        // Ignore require error
+      }
+
+      return 'unknown';
+    } catch (error) {
+      return 'unknown';
+    }
+  }
+}

src/telemetry/event-tracker.ts

@@ -0,0 +1,484 @@
+/**
+ * Event Tracker for Telemetry
+ * Handles all event tracking logic extracted from TelemetryManager
+ */
+
+import { TelemetryEvent, WorkflowTelemetry } from './telemetry-types';
+import { WorkflowSanitizer } from './workflow-sanitizer';
+import { TelemetryRateLimiter } from './rate-limiter';
+import { TelemetryEventValidator } from './event-validator';
+import { TelemetryError, TelemetryErrorType } from './telemetry-error';
+import { logger } from '../utils/logger';
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+
+export class TelemetryEventTracker {
+  private rateLimiter: TelemetryRateLimiter;
+  private validator: TelemetryEventValidator;
+  private eventQueue: TelemetryEvent[] = [];
+  private workflowQueue: WorkflowTelemetry[] = [];
+  private previousTool?: string;
+  private previousToolTimestamp: number = 0;
+  private performanceMetrics: Map<string, number[]> = new Map();
+
+  constructor(
+    private getUserId: () => string,
+    private isEnabled: () => boolean
+  ) {
+    this.rateLimiter = new TelemetryRateLimiter();
+    this.validator = new TelemetryEventValidator();
+  }
+
+  /**
+   * Track a tool usage event
+   */
+  trackToolUsage(toolName: string, success: boolean, duration?: number): void {
+    if (!this.isEnabled()) return;
+
+    // Check rate limit
+    if (!this.rateLimiter.allow()) {
+      logger.debug(`Rate limited: tool_used event for ${toolName}`);
+      return;
+    }
+
+    // Track performance metrics
+    if (duration !== undefined) {
+      this.recordPerformanceMetric(toolName, duration);
+    }
+
+    const event: TelemetryEvent = {
+      user_id: this.getUserId(),
+      event: 'tool_used',
+      properties: {
+        tool: toolName.replace(/[^a-zA-Z0-9_-]/g, '_'),
+        success,
+        duration: duration || 0,
+      }
+    };
+
+    // Validate and queue
+    const validated = this.validator.validateEvent(event);
+    if (validated) {
+      this.eventQueue.push(validated);
+    }
+  }
+
+  /**
+   * Track workflow creation
+   */
+  async trackWorkflowCreation(workflow: any, validationPassed: boolean): Promise<void> {
+    if (!this.isEnabled()) return;
+
+    // Check rate limit
+    if (!this.rateLimiter.allow()) {
+      logger.debug('Rate limited: workflow creation event');
+      return;
+    }
+
+    // Only store workflows that pass validation
+    if (!validationPassed) {
+      this.trackEvent('workflow_validation_failed', {
+        nodeCount: workflow.nodes?.length || 0,
+      });
+      return;
+    }
+
+    try {
+      const sanitized = WorkflowSanitizer.sanitizeWorkflow(workflow);
+
+      const telemetryData: WorkflowTelemetry = {
+        user_id: this.getUserId(),
+        workflow_hash: sanitized.workflowHash,
+        node_count: sanitized.nodeCount,
+        node_types: sanitized.nodeTypes,
+        has_trigger: sanitized.hasTrigger,
+        has_webhook: sanitized.hasWebhook,
+        complexity: sanitized.complexity,
+        sanitized_workflow: {
+          nodes: sanitized.nodes,
+          connections: sanitized.connections,
+        },
+      };
+
+      // Validate workflow telemetry
+      const validated = this.validator.validateWorkflow(telemetryData);
+      if (validated) {
+        this.workflowQueue.push(validated);
+
+        // Also track as event
+        this.trackEvent('workflow_created', {
+          nodeCount: sanitized.nodeCount,
+          nodeTypes: sanitized.nodeTypes.length,
+          complexity: sanitized.complexity,
+          hasTrigger: sanitized.hasTrigger,
+          hasWebhook: sanitized.hasWebhook,
+        });
+      }
+    } catch (error) {
+      logger.debug('Failed to track workflow creation:', error);
+      throw new TelemetryError(
+        TelemetryErrorType.VALIDATION_ERROR,
+        'Failed to sanitize workflow',
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  }
+
+  /**
+   * Track an error event
+   */
+  trackError(errorType: string, context: string, toolName?: string, errorMessage?: string): void {
+    if (!this.isEnabled()) return;
+
+    // Don't rate limit error tracking - we want to see all errors
+    this.trackEvent('error_occurred', {
+      errorType: this.sanitizeErrorType(errorType),
+      context: this.sanitizeContext(context),
+      tool: toolName ? toolName.replace(/[^a-zA-Z0-9_-]/g, '_') : undefined,
+      error: errorMessage ? this.sanitizeErrorMessage(errorMessage) : undefined,
+    }, false); // Skip rate limiting for errors
+  }
+
+  /**
+   * Track a generic event
+   */
+  trackEvent(eventName: string, properties: Record<string, any>, checkRateLimit: boolean = true): void {
+    if (!this.isEnabled()) return;
+
+    // Check rate limit unless explicitly skipped
+    if (checkRateLimit && !this.rateLimiter.allow()) {
+      logger.debug(`Rate limited: ${eventName} event`);
+      return;
+    }
+
+    const event: TelemetryEvent = {
+      user_id: this.getUserId(),
+      event: eventName,
+      properties,
+    };
+
+    // Validate and queue
+    const validated = this.validator.validateEvent(event);
+    if (validated) {
+      this.eventQueue.push(validated);
+    }
+  }
+
+  /**
+   * Track session start
+   */
+  trackSessionStart(): void {
+    if (!this.isEnabled()) return;
+
+    this.trackEvent('session_start', {
+      version: this.getPackageVersion(),
+      platform: process.platform,
+      arch: process.arch,
+      nodeVersion: process.version,
+    });
+  }
+
+  /**
+   * Track search queries
+   */
+  trackSearchQuery(query: string, resultsFound: number, searchType: string): void {
+    if (!this.isEnabled()) return;
+
+    this.trackEvent('search_query', {
+      query: query.substring(0, 100),
+      resultsFound,
+      searchType,
+      hasResults: resultsFound > 0,
+      isZeroResults: resultsFound === 0
+    });
+  }
+
+  /**
+   * Track validation details
+   */
+  trackValidationDetails(nodeType: string, errorType: string, details: Record<string, any>): void {
+    if (!this.isEnabled()) return;
+
+    this.trackEvent('validation_details', {
+      nodeType: nodeType.replace(/[^a-zA-Z0-9_.-]/g, '_'),
+      errorType: this.sanitizeErrorType(errorType),
+      errorCategory: this.categorizeError(errorType),
+      details
+    });
+  }
+
+  /**
+   * Track tool usage sequences
+   */
+  trackToolSequence(previousTool: string, currentTool: string, timeDelta: number): void {
+    if (!this.isEnabled()) return;
+
+    this.trackEvent('tool_sequence', {
+      previousTool: previousTool.replace(/[^a-zA-Z0-9_-]/g, '_'),
+      currentTool: currentTool.replace(/[^a-zA-Z0-9_-]/g, '_'),
+      timeDelta: Math.min(timeDelta, 300000), // Cap at 5 minutes
+      isSlowTransition: timeDelta > 10000,
+      sequence: `${previousTool}->${currentTool}`
+    });
+  }
+
+  /**
+   * Track node configuration patterns
+   */
+  trackNodeConfiguration(nodeType: string, propertiesSet: number, usedDefaults: boolean): void {
+    if (!this.isEnabled()) return;
+
+    this.trackEvent('node_configuration', {
+      nodeType: nodeType.replace(/[^a-zA-Z0-9_.-]/g, '_'),
+      propertiesSet,
+      usedDefaults,
+      complexity: this.categorizeConfigComplexity(propertiesSet)
+    });
+  }
+
+  /**
+   * Track performance metrics
+   */
+  trackPerformanceMetric(operation: string, duration: number, metadata?: Record<string, any>): void {
+    if (!this.isEnabled()) return;
+
+    // Record for internal metrics
+    this.recordPerformanceMetric(operation, duration);
+
+    this.trackEvent('performance_metric', {
+      operation: operation.replace(/[^a-zA-Z0-9_-]/g, '_'),
+      duration,
+      isSlow: duration > 1000,
+      isVerySlow: duration > 5000,
+      metadata
+    });
+  }
+
+  /**
+   * Update tool sequence tracking
+   */
+  updateToolSequence(toolName: string): void {
+    if (this.previousTool) {
+      const timeDelta = Date.now() - this.previousToolTimestamp;
+      this.trackToolSequence(this.previousTool, toolName, timeDelta);
+    }
+
+    this.previousTool = toolName;
+    this.previousToolTimestamp = Date.now();
+  }
+
+  /**
+   * Get queued events
+   */
+  getEventQueue(): TelemetryEvent[] {
+    return [...this.eventQueue];
+  }
+
+  /**
+   * Get queued workflows
+   */
+  getWorkflowQueue(): WorkflowTelemetry[] {
+    return [...this.workflowQueue];
+  }
+
+  /**
+   * Clear event queue
+   */
+  clearEventQueue(): void {
+    this.eventQueue = [];
+  }
+
+  /**
+   * Clear workflow queue
+   */
+  clearWorkflowQueue(): void {
+    this.workflowQueue = [];
+  }
+
+  /**
+   * Get tracking statistics
+   */
+  getStats() {
+    return {
+      rateLimiter: this.rateLimiter.getStats(),
+      validator: this.validator.getStats(),
+      eventQueueSize: this.eventQueue.length,
+      workflowQueueSize: this.workflowQueue.length,
+      performanceMetrics: this.getPerformanceStats()
+    };
+  }
+
+  /**
+   * Record performance metric internally
+   */
+  private recordPerformanceMetric(operation: string, duration: number): void {
+    if (!this.performanceMetrics.has(operation)) {
+      this.performanceMetrics.set(operation, []);
+    }
+
+    const metrics = this.performanceMetrics.get(operation)!;
+    metrics.push(duration);
+
+    // Keep only last 100 measurements
+    if (metrics.length > 100) {
+      metrics.shift();
+    }
+  }
+
+  /**
+   * Get performance statistics
+   */
+  private getPerformanceStats() {
+    const stats: Record<string, any> = {};
+
+    for (const [operation, durations] of this.performanceMetrics.entries()) {
+      if (durations.length === 0) continue;
+
+      const sorted = [...durations].sort((a, b) => a - b);
+      const sum = sorted.reduce((a, b) => a + b, 0);
+
+      stats[operation] = {
+        count: sorted.length,
+        min: sorted[0],
+        max: sorted[sorted.length - 1],
+        avg: Math.round(sum / sorted.length),
+        p50: sorted[Math.floor(sorted.length * 0.5)],
+        p95: sorted[Math.floor(sorted.length * 0.95)],
+        p99: sorted[Math.floor(sorted.length * 0.99)]
+      };
+    }
+
+    return stats;
+  }
+
+  /**
+   * Categorize error types
+   */
+  private categorizeError(errorType: string): string {
+    const lowerError = errorType.toLowerCase();
+    if (lowerError.includes('type')) return 'type_error';
+    if (lowerError.includes('validation')) return 'validation_error';
+    if (lowerError.includes('required')) return 'required_field_error';
+    if (lowerError.includes('connection')) return 'connection_error';
+    if (lowerError.includes('expression')) return 'expression_error';
+    return 'other_error';
+  }
+
+  /**
+   * Categorize configuration complexity
+   */
+  private categorizeConfigComplexity(propertiesSet: number): string {
+    if (propertiesSet === 0) return 'defaults_only';
+    if (propertiesSet <= 3) return 'simple';
+    if (propertiesSet <= 10) return 'moderate';
+    return 'complex';
+  }
+
+  /**
+   * Get package version
+   */
+  private getPackageVersion(): string {
+    try {
+      const possiblePaths = [
+        resolve(__dirname, '..', '..', 'package.json'),
+        resolve(process.cwd(), 'package.json'),
+        resolve(__dirname, '..', '..', '..', 'package.json')
+      ];
+
+      for (const packagePath of possiblePaths) {
+        if (existsSync(packagePath)) {
+          const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+          if (packageJson.version) {
+            return packageJson.version;
+          }
+        }
+      }
+
+      return 'unknown';
+    } catch (error) {
+      logger.debug('Failed to get package version:', error);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Sanitize error type
+   */
+  private sanitizeErrorType(errorType: string): string {
+    return errorType.replace(/[^a-zA-Z0-9_-]/g, '_').substring(0, 50);
+  }
+
+  /**
+   * Sanitize context
+   */
+  private sanitizeContext(context: string): string {
+    // Sanitize in a specific order to preserve some structure
+    let sanitized = context
+      // First replace emails (before URLs eat them)
+      .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]')
+      // Then replace long keys (32+ chars to match validator)
+      .replace(/\b[a-zA-Z0-9_-]{32,}/g, '[KEY]')
+      // Finally replace URLs but keep the path structure
+      .replace(/(https?:\/\/)([^\s\/]+)(\/[^\s]*)?/gi, (match, protocol, domain, path) => {
+        return '[URL]' + (path || '');
+      });
+
+    // Then truncate if needed
+    if (sanitized.length > 100) {
+      sanitized = sanitized.substring(0, 100);
+    }
+    return sanitized;
+  }
+
+  /**
+   * Sanitize error message
+   */
+  private sanitizeErrorMessage(errorMessage: string): string {
+    try {
+      // Early truncate to prevent ReDoS and performance issues
+      const maxLength = 1500;
+      const trimmed = errorMessage.length > maxLength
+        ? errorMessage.substring(0, maxLength)
+        : errorMessage;
+
+      // Handle stack traces - keep only first 3 lines (message + top stack frames)
+      const lines = trimmed.split('\n');
+      let sanitized = lines.slice(0, 3).join('\n');
+
+      // Sanitize sensitive data in correct order to prevent leakage
+      // 1. URLs first (most encompassing) - fully redact to prevent path leakage
+      sanitized = sanitized.replace(/https?:\/\/\S+/gi, '[URL]');
+
+      // 2. Specific credential patterns (before generic patterns)
+      sanitized = sanitized
+        .replace(/AKIA[A-Z0-9]{16}/g, '[AWS_KEY]')
+        .replace(/ghp_[a-zA-Z0-9]{36,}/g, '[GITHUB_TOKEN]')
+        .replace(/eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, '[JWT]')
+        .replace(/Bearer\s+[^\s]+/gi, 'Bearer [TOKEN]');
+
+      // 3. Emails (after URLs to avoid partial matches)
+      sanitized = sanitized.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]');
+
+      // 4. Long keys and quoted tokens
+      sanitized = sanitized
+        .replace(/\b[a-zA-Z0-9_-]{32,}\b/g, '[KEY]')
+        .replace(/(['"])[a-zA-Z0-9_-]{16,}\1/g, '$1[TOKEN]$1');
+
+      // 5. Generic credential patterns (after specific ones to avoid conflicts)
+      sanitized = sanitized
+        .replace(/password\s*[=:]\s*\S+/gi, 'password=[REDACTED]')
+        .replace(/api[_-]?key\s*[=:]\s*\S+/gi, 'api_key=[REDACTED]')
+        .replace(/(?<!Bearer\s)token\s*[=:]\s*\S+/gi, 'token=[REDACTED]');  // Negative lookbehind to avoid Bearer tokens
+
+      // Final truncate to 500 chars
+      if (sanitized.length > 500) {
+        sanitized = sanitized.substring(0, 500) + '...';
+      }
+
+      return sanitized;
+    } catch (error) {
+      logger.debug('Error message sanitization failed:', error);
+      return '[SANITIZATION_FAILED]';
+    }
+  }
+}

src/telemetry/event-validator.ts

@@ -0,0 +1,278 @@
+/**
+ * Event Validator for Telemetry
+ * Validates and sanitizes telemetry events using Zod schemas
+ */
+
+import { z } from 'zod';
+import { TelemetryEvent, WorkflowTelemetry } from './telemetry-types';
+import { logger } from '../utils/logger';
+
+// Base property schema that sanitizes strings
+const sanitizedString = z.string().transform(val => {
+  // Remove URLs
+  let sanitized = val.replace(/https?:\/\/[^\s]+/gi, '[URL]');
+  // Remove potential API keys
+  sanitized = sanitized.replace(/[a-zA-Z0-9_-]{32,}/g, '[KEY]');
+  // Remove emails
+  sanitized = sanitized.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]');
+  return sanitized;
+});
+
+// Schema for generic event properties
+const eventPropertiesSchema = z.record(z.unknown()).transform(obj => {
+  const sanitized: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    // Skip sensitive keys
+    if (isSensitiveKey(key)) {
+      continue;
+    }
+
+    // Sanitize string values
+    if (typeof value === 'string') {
+      sanitized[key] = sanitizedString.parse(value);
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+      sanitized[key] = value;
+    } else if (value === null || value === undefined) {
+      sanitized[key] = null;
+    } else if (typeof value === 'object') {
+      // Recursively sanitize nested objects (limited depth)
+      sanitized[key] = sanitizeNestedObject(value, 3);
+    }
+  }
+
+  return sanitized;
+});
+
+// Schema for telemetry events
+export const telemetryEventSchema = z.object({
+  user_id: z.string().min(1).max(64),
+  event: z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/),
+  properties: eventPropertiesSchema,
+  created_at: z.string().datetime().optional()
+});
+
+// Schema for workflow telemetry
+export const workflowTelemetrySchema = z.object({
+  user_id: z.string().min(1).max(64),
+  workflow_hash: z.string().min(1).max(64),
+  node_count: z.number().int().min(0).max(1000),
+  node_types: z.array(z.string()).max(100),
+  has_trigger: z.boolean(),
+  has_webhook: z.boolean(),
+  complexity: z.enum(['simple', 'medium', 'complex']),
+  sanitized_workflow: z.object({
+    nodes: z.array(z.any()).max(1000),
+    connections: z.record(z.any())
+  }),
+  created_at: z.string().datetime().optional()
+});
+
+// Specific event property schemas for common events
+const toolUsagePropertiesSchema = z.object({
+  tool: z.string().max(100),
+  success: z.boolean(),
+  duration: z.number().min(0).max(3600000), // Max 1 hour
+});
+
+const searchQueryPropertiesSchema = z.object({
+  query: z.string().max(100).transform(val => {
+    // Apply same sanitization as sanitizedString
+    let sanitized = val.replace(/https?:\/\/[^\s]+/gi, '[URL]');
+    sanitized = sanitized.replace(/[a-zA-Z0-9_-]{32,}/g, '[KEY]');
+    sanitized = sanitized.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL]');
+    return sanitized;
+  }),
+  resultsFound: z.number().int().min(0),
+  searchType: z.string().max(50),
+  hasResults: z.boolean(),
+  isZeroResults: z.boolean()
+});
+
+const validationDetailsPropertiesSchema = z.object({
+  nodeType: z.string().max(100),
+  errorType: z.string().max(100),
+  errorCategory: z.string().max(50),
+  details: z.record(z.any()).optional()
+});
+
+const performanceMetricPropertiesSchema = z.object({
+  operation: z.string().max(100),
+  duration: z.number().min(0).max(3600000),
+  isSlow: z.boolean(),
+  isVerySlow: z.boolean(),
+  metadata: z.record(z.any()).optional()
+});
+
+// Map of event names to their specific schemas
+const EVENT_SCHEMAS: Record<string, z.ZodSchema<any>> = {
+  'tool_used': toolUsagePropertiesSchema,
+  'search_query': searchQueryPropertiesSchema,
+  'validation_details': validationDetailsPropertiesSchema,
+  'performance_metric': performanceMetricPropertiesSchema,
+};
+
+/**
+ * Check if a key is sensitive
+ * Handles various naming conventions: camelCase, snake_case, kebab-case, and case variations
+ */
+function isSensitiveKey(key: string): boolean {
+  const sensitivePatterns = [
+    // Core sensitive terms
+    'password', 'passwd', 'pwd',
+    'token', 'jwt', 'bearer',
+    'apikey', 'api_key', 'api-key',
+    'secret', 'private',
+    'credential', 'cred', 'auth',
+
+    // Network/Connection sensitive
+    'url', 'uri', 'endpoint', 'host', 'hostname',
+    'database', 'db', 'connection', 'conn',
+
+    // Service-specific
+    'slack', 'discord', 'telegram',
+    'oauth', 'client_secret', 'client-secret', 'clientsecret',
+    'access_token', 'access-token', 'accesstoken',
+    'refresh_token', 'refresh-token', 'refreshtoken'
+  ];
+
+  const lowerKey = key.toLowerCase();
+
+  // Check for exact matches first (most efficient)
+  if (sensitivePatterns.includes(lowerKey)) {
+    return true;
+  }
+
+  // Check for compound key terms specifically
+  if (lowerKey.includes('key') && lowerKey !== 'key') {
+    // Check if it's a compound term like apikey, api_key, etc.
+    const keyPatterns = ['apikey', 'api_key', 'api-key', 'secretkey', 'secret_key', 'privatekey', 'private_key'];
+    if (keyPatterns.some(pattern => lowerKey.includes(pattern))) {
+      return true;
+    }
+  }
+
+  // Check for substring matches with word boundaries
+  return sensitivePatterns.some(pattern => {
+    // Match as whole words or with common separators
+    const regex = new RegExp(`(?:^|[_-])${pattern}(?:[_-]|$)`, 'i');
+    return regex.test(key) || lowerKey.includes(pattern);
+  });
+}
+
+/**
+ * Sanitize nested objects with depth limit
+ */
+function sanitizeNestedObject(obj: any, maxDepth: number): any {
+  if (maxDepth <= 0 || !obj || typeof obj !== 'object') {
+    return '[NESTED]';
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.slice(0, 10).map(item =>
+      typeof item === 'object' ? sanitizeNestedObject(item, maxDepth - 1) : item
+    );
+  }
+
+  const sanitized: Record<string, any> = {};
+  let keyCount = 0;
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (keyCount++ >= 20) { // Limit keys per object
+      sanitized['...'] = 'truncated';
+      break;
+    }
+
+    if (isSensitiveKey(key)) {
+      continue;
+    }
+
+    if (typeof value === 'string') {
+      sanitized[key] = sanitizedString.parse(value);
+    } else if (typeof value === 'object' && value !== null) {
+      sanitized[key] = sanitizeNestedObject(value, maxDepth - 1);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+
+  return sanitized;
+}
+
+export class TelemetryEventValidator {
+  private validationErrors: number = 0;
+  private validationSuccesses: number = 0;
+
+  /**
+   * Validate and sanitize a telemetry event
+   */
+  validateEvent(event: TelemetryEvent): TelemetryEvent | null {
+    try {
+      // Use specific schema if available for this event type
+      const specificSchema = EVENT_SCHEMAS[event.event];
+
+      if (specificSchema) {
+        // Validate properties with specific schema first
+        const validatedProperties = specificSchema.safeParse(event.properties);
+        if (!validatedProperties.success) {
+          logger.debug(`Event validation failed for ${event.event}:`, validatedProperties.error.errors);
+          this.validationErrors++;
+          return null;
+        }
+        event.properties = validatedProperties.data;
+      }
+
+      // Validate the complete event
+      const validated = telemetryEventSchema.parse(event);
+      this.validationSuccesses++;
+      return validated;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        logger.debug('Event validation error:', error.errors);
+      } else {
+        logger.debug('Unexpected validation error:', error);
+      }
+      this.validationErrors++;
+      return null;
+    }
+  }
+
+  /**
+   * Validate workflow telemetry
+   */
+  validateWorkflow(workflow: WorkflowTelemetry): WorkflowTelemetry | null {
+    try {
+      const validated = workflowTelemetrySchema.parse(workflow);
+      this.validationSuccesses++;
+      return validated;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        logger.debug('Workflow validation error:', error.errors);
+      } else {
+        logger.debug('Unexpected workflow validation error:', error);
+      }
+      this.validationErrors++;
+      return null;
+    }
+  }
+
+  /**
+   * Get validation statistics
+   */
+  getStats() {
+    return {
+      errors: this.validationErrors,
+      successes: this.validationSuccesses,
+      total: this.validationErrors + this.validationSuccesses,
+      errorRate: this.validationErrors / (this.validationErrors + this.validationSuccesses) || 0
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats(): void {
+    this.validationErrors = 0;
+    this.validationSuccesses = 0;
+  }
+}

src/telemetry/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Telemetry Module
+ * Exports for anonymous usage statistics
+ */
+
+export { TelemetryManager, telemetry } from './telemetry-manager';
+export { TelemetryConfigManager } from './config-manager';
+export { WorkflowSanitizer } from './workflow-sanitizer';
+export type { TelemetryConfig } from './config-manager';

src/telemetry/performance-monitor.ts

@@ -0,0 +1,303 @@
+/**
+ * Performance Monitor for Telemetry
+ * Tracks telemetry overhead and provides performance insights
+ */
+
+import { logger } from '../utils/logger';
+
+interface PerformanceMetric {
+  operation: string;
+  duration: number;
+  timestamp: number;
+  memory?: {
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+  };
+}
+
+export class TelemetryPerformanceMonitor {
+  private metrics: PerformanceMetric[] = [];
+  private operationTimers: Map<string, number> = new Map();
+  private readonly maxMetrics = 1000;
+  private startupTime = Date.now();
+  private operationCounts: Map<string, number> = new Map();
+
+  /**
+   * Start timing an operation
+   */
+  startOperation(operation: string): void {
+    this.operationTimers.set(operation, performance.now());
+  }
+
+  /**
+   * End timing an operation and record metrics
+   */
+  endOperation(operation: string): number {
+    const startTime = this.operationTimers.get(operation);
+    if (!startTime) {
+      logger.debug(`No start time found for operation: ${operation}`);
+      return 0;
+    }
+
+    const duration = performance.now() - startTime;
+    this.operationTimers.delete(operation);
+
+    // Record the metric
+    const metric: PerformanceMetric = {
+      operation,
+      duration,
+      timestamp: Date.now(),
+      memory: this.captureMemoryUsage()
+    };
+
+    this.recordMetric(metric);
+
+    // Update operation count
+    const count = this.operationCounts.get(operation) || 0;
+    this.operationCounts.set(operation, count + 1);
+
+    return duration;
+  }
+
+  /**
+   * Record a performance metric
+   */
+  private recordMetric(metric: PerformanceMetric): void {
+    this.metrics.push(metric);
+
+    // Keep only recent metrics
+    if (this.metrics.length > this.maxMetrics) {
+      this.metrics.shift();
+    }
+
+    // Log slow operations
+    if (metric.duration > 100) {
+      logger.debug(`Slow telemetry operation: ${metric.operation} took ${metric.duration.toFixed(2)}ms`);
+    }
+  }
+
+  /**
+   * Capture current memory usage
+   */
+  private captureMemoryUsage() {
+    if (typeof process !== 'undefined' && process.memoryUsage) {
+      const usage = process.memoryUsage();
+      return {
+        heapUsed: Math.round(usage.heapUsed / 1024 / 1024), // MB
+        heapTotal: Math.round(usage.heapTotal / 1024 / 1024), // MB
+        external: Math.round(usage.external / 1024 / 1024) // MB
+      };
+    }
+    return undefined;
+  }
+
+  /**
+   * Get performance statistics
+   */
+  getStatistics() {
+    const now = Date.now();
+    const recentMetrics = this.metrics.filter(m => now - m.timestamp < 60000); // Last minute
+
+    if (recentMetrics.length === 0) {
+      return {
+        totalOperations: 0,
+        averageDuration: 0,
+        slowOperations: 0,
+        operationsByType: {},
+        memoryUsage: this.captureMemoryUsage(),
+        uptimeMs: now - this.startupTime,
+        overhead: {
+          percentage: 0,
+          totalMs: 0
+        }
+      };
+    }
+
+    // Calculate statistics
+    const durations = recentMetrics.map(m => m.duration);
+    const totalDuration = durations.reduce((a, b) => a + b, 0);
+    const avgDuration = totalDuration / durations.length;
+    const slowOps = durations.filter(d => d > 50).length;
+
+    // Group by operation type
+    const operationsByType: Record<string, { count: number; avgDuration: number }> = {};
+    const typeGroups = new Map<string, number[]>();
+
+    for (const metric of recentMetrics) {
+      const type = metric.operation;
+      if (!typeGroups.has(type)) {
+        typeGroups.set(type, []);
+      }
+      typeGroups.get(type)!.push(metric.duration);
+    }
+
+    for (const [type, durations] of typeGroups.entries()) {
+      const sum = durations.reduce((a, b) => a + b, 0);
+      operationsByType[type] = {
+        count: durations.length,
+        avgDuration: Math.round(sum / durations.length * 100) / 100
+      };
+    }
+
+    // Estimate overhead
+    const estimatedOverheadPercentage = Math.min(5, avgDuration / 10); // Rough estimate
+
+    return {
+      totalOperations: this.operationCounts.size,
+      operationsInLastMinute: recentMetrics.length,
+      averageDuration: Math.round(avgDuration * 100) / 100,
+      slowOperations: slowOps,
+      operationsByType,
+      memoryUsage: this.captureMemoryUsage(),
+      uptimeMs: now - this.startupTime,
+      overhead: {
+        percentage: estimatedOverheadPercentage,
+        totalMs: totalDuration
+      }
+    };
+  }
+
+  /**
+   * Get detailed performance report
+   */
+  getDetailedReport() {
+    const stats = this.getStatistics();
+    const percentiles = this.calculatePercentiles();
+
+    return {
+      summary: stats,
+      percentiles,
+      topSlowOperations: this.getTopSlowOperations(5),
+      memoryTrend: this.getMemoryTrend(),
+      recommendations: this.generateRecommendations(stats, percentiles)
+    };
+  }
+
+  /**
+   * Calculate percentiles for recent operations
+   */
+  private calculatePercentiles() {
+    const recentDurations = this.metrics
+      .filter(m => Date.now() - m.timestamp < 60000)
+      .map(m => m.duration)
+      .sort((a, b) => a - b);
+
+    if (recentDurations.length === 0) {
+      return { p50: 0, p75: 0, p90: 0, p95: 0, p99: 0 };
+    }
+
+    return {
+      p50: this.percentile(recentDurations, 0.5),
+      p75: this.percentile(recentDurations, 0.75),
+      p90: this.percentile(recentDurations, 0.9),
+      p95: this.percentile(recentDurations, 0.95),
+      p99: this.percentile(recentDurations, 0.99)
+    };
+  }
+
+  /**
+   * Calculate a specific percentile
+   */
+  private percentile(sorted: number[], p: number): number {
+    const index = Math.ceil(sorted.length * p) - 1;
+    return Math.round(sorted[Math.max(0, index)] * 100) / 100;
+  }
+
+  /**
+   * Get top slow operations
+   */
+  private getTopSlowOperations(n: number) {
+    return [...this.metrics]
+      .sort((a, b) => b.duration - a.duration)
+      .slice(0, n)
+      .map(m => ({
+        operation: m.operation,
+        duration: Math.round(m.duration * 100) / 100,
+        timestamp: m.timestamp
+      }));
+  }
+
+  /**
+   * Get memory usage trend
+   */
+  private getMemoryTrend() {
+    const metricsWithMemory = this.metrics.filter(m => m.memory);
+    if (metricsWithMemory.length < 2) {
+      return { trend: 'stable', delta: 0 };
+    }
+
+    const recent = metricsWithMemory.slice(-10);
+    const first = recent[0].memory!;
+    const last = recent[recent.length - 1].memory!;
+    const delta = last.heapUsed - first.heapUsed;
+
+    let trend: 'increasing' | 'decreasing' | 'stable';
+    if (delta > 5) trend = 'increasing';
+    else if (delta < -5) trend = 'decreasing';
+    else trend = 'stable';
+
+    return { trend, delta };
+  }
+
+  /**
+   * Generate performance recommendations
+   */
+  private generateRecommendations(stats: any, percentiles: any): string[] {
+    const recommendations: string[] = [];
+
+    // Check for high average duration
+    if (stats.averageDuration > 50) {
+      recommendations.push('Consider batching more events to reduce overhead');
+    }
+
+    // Check for slow operations
+    if (stats.slowOperations > stats.operationsInLastMinute * 0.1) {
+      recommendations.push('Many slow operations detected - investigate network latency');
+    }
+
+    // Check p99 percentile
+    if (percentiles.p99 > 200) {
+      recommendations.push('P99 latency is high - consider implementing local queue persistence');
+    }
+
+    // Check memory trend
+    const memoryTrend = this.getMemoryTrend();
+    if (memoryTrend.trend === 'increasing' && memoryTrend.delta > 10) {
+      recommendations.push('Memory usage is increasing - check for memory leaks');
+    }
+
+    // Check operation count
+    if (stats.operationsInLastMinute > 1000) {
+      recommendations.push('High telemetry volume - ensure rate limiting is effective');
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Reset all metrics
+   */
+  reset(): void {
+    this.metrics = [];
+    this.operationTimers.clear();
+    this.operationCounts.clear();
+    this.startupTime = Date.now();
+  }
+
+  /**
+   * Get telemetry overhead estimate
+   */
+  getTelemetryOverhead(): { percentage: number; impact: 'minimal' | 'low' | 'moderate' | 'high' } {
+    const stats = this.getStatistics();
+    const percentage = stats.overhead.percentage;
+
+    let impact: 'minimal' | 'low' | 'moderate' | 'high';
+    if (percentage < 1) impact = 'minimal';
+    else if (percentage < 3) impact = 'low';
+    else if (percentage < 5) impact = 'moderate';
+    else impact = 'high';
+
+    return { percentage, impact };
+  }
+}

src/telemetry/rate-limiter.ts

@@ -0,0 +1,173 @@
+/**
+ * Rate Limiter for Telemetry
+ * Implements sliding window rate limiting to prevent excessive telemetry events
+ */
+
+import { TELEMETRY_CONFIG } from './telemetry-types';
+import { logger } from '../utils/logger';
+
+export class TelemetryRateLimiter {
+  private eventTimestamps: number[] = [];
+  private windowMs: number;
+  private maxEvents: number;
+  private droppedEventsCount: number = 0;
+  private lastWarningTime: number = 0;
+  private readonly WARNING_INTERVAL = 60000; // Warn at most once per minute
+  private readonly MAX_ARRAY_SIZE = 1000; // Prevent memory leaks by limiting array size
+
+  constructor(
+    windowMs: number = TELEMETRY_CONFIG.RATE_LIMIT_WINDOW,
+    maxEvents: number = TELEMETRY_CONFIG.RATE_LIMIT_MAX_EVENTS
+  ) {
+    this.windowMs = windowMs;
+    this.maxEvents = maxEvents;
+  }
+
+  /**
+   * Check if an event can be tracked based on rate limits
+   * Returns true if event can proceed, false if rate limited
+   */
+  allow(): boolean {
+    const now = Date.now();
+
+    // Clean up old timestamps outside the window
+    this.cleanupOldTimestamps(now);
+
+    // Check if we've hit the rate limit
+    if (this.eventTimestamps.length >= this.maxEvents) {
+      this.handleRateLimitHit(now);
+      return false;
+    }
+
+    // Add current timestamp and allow event
+    this.eventTimestamps.push(now);
+    return true;
+  }
+
+  /**
+   * Check if rate limiting would occur without actually blocking
+   * Useful for pre-flight checks
+   */
+  wouldAllow(): boolean {
+    const now = Date.now();
+    this.cleanupOldTimestamps(now);
+    return this.eventTimestamps.length < this.maxEvents;
+  }
+
+  /**
+   * Get current usage statistics
+   */
+  getStats() {
+    const now = Date.now();
+    this.cleanupOldTimestamps(now);
+
+    return {
+      currentEvents: this.eventTimestamps.length,
+      maxEvents: this.maxEvents,
+      windowMs: this.windowMs,
+      droppedEvents: this.droppedEventsCount,
+      utilizationPercent: Math.round((this.eventTimestamps.length / this.maxEvents) * 100),
+      remainingCapacity: Math.max(0, this.maxEvents - this.eventTimestamps.length),
+      arraySize: this.eventTimestamps.length,
+      maxArraySize: this.MAX_ARRAY_SIZE,
+      memoryUsagePercent: Math.round((this.eventTimestamps.length / this.MAX_ARRAY_SIZE) * 100)
+    };
+  }
+
+  /**
+   * Reset the rate limiter (useful for testing)
+   */
+  reset(): void {
+    this.eventTimestamps = [];
+    this.droppedEventsCount = 0;
+    this.lastWarningTime = 0;
+  }
+
+  /**
+   * Clean up timestamps outside the current window and enforce array size limit
+   */
+  private cleanupOldTimestamps(now: number): void {
+    const windowStart = now - this.windowMs;
+
+    // Remove all timestamps before the window start
+    let i = 0;
+    while (i < this.eventTimestamps.length && this.eventTimestamps[i] < windowStart) {
+      i++;
+    }
+
+    if (i > 0) {
+      this.eventTimestamps.splice(0, i);
+    }
+
+    // Enforce maximum array size to prevent memory leaks
+    if (this.eventTimestamps.length > this.MAX_ARRAY_SIZE) {
+      const excess = this.eventTimestamps.length - this.MAX_ARRAY_SIZE;
+      this.eventTimestamps.splice(0, excess);
+
+      if (now - this.lastWarningTime > this.WARNING_INTERVAL) {
+        logger.debug(
+          `Telemetry rate limiter array trimmed: removed ${excess} oldest timestamps to prevent memory leak. ` +
+          `Array size: ${this.eventTimestamps.length}/${this.MAX_ARRAY_SIZE}`
+        );
+        this.lastWarningTime = now;
+      }
+    }
+  }
+
+  /**
+   * Handle rate limit hit
+   */
+  private handleRateLimitHit(now: number): void {
+    this.droppedEventsCount++;
+
+    // Log warning if enough time has passed since last warning
+    if (now - this.lastWarningTime > this.WARNING_INTERVAL) {
+      const stats = this.getStats();
+      logger.debug(
+        `Telemetry rate limit reached: ${stats.currentEvents}/${stats.maxEvents} events in ${stats.windowMs}ms window. ` +
+        `Total dropped: ${stats.droppedEvents}`
+      );
+      this.lastWarningTime = now;
+    }
+  }
+
+  /**
+   * Get the number of dropped events
+   */
+  getDroppedEventsCount(): number {
+    return this.droppedEventsCount;
+  }
+
+  /**
+   * Estimate time until capacity is available (in ms)
+   * Returns 0 if capacity is available now
+   */
+  getTimeUntilCapacity(): number {
+    const now = Date.now();
+    this.cleanupOldTimestamps(now);
+
+    if (this.eventTimestamps.length < this.maxEvents) {
+      return 0;
+    }
+
+    // Find the oldest timestamp that would need to expire
+    const oldestRelevant = this.eventTimestamps[this.eventTimestamps.length - this.maxEvents];
+    const timeUntilExpiry = Math.max(0, (oldestRelevant + this.windowMs) - now);
+
+    return timeUntilExpiry;
+  }
+
+  /**
+   * Update rate limit configuration dynamically
+   */
+  updateLimits(windowMs?: number, maxEvents?: number): void {
+    if (windowMs !== undefined && windowMs > 0) {
+      this.windowMs = windowMs;
+    }
+    if (maxEvents !== undefined && maxEvents > 0) {
+      this.maxEvents = maxEvents;
+    }
+
+    logger.debug(`Rate limiter updated: ${this.maxEvents} events per ${this.windowMs}ms`);
+  }
+}

src/telemetry/telemetry-error.ts

@@ -0,0 +1,244 @@
+/**
+ * Telemetry Error Classes
+ * Custom error types for telemetry system with enhanced tracking
+ */
+
+import { TelemetryErrorType, TelemetryErrorContext } from './telemetry-types';
+import { logger } from '../utils/logger';
+
+// Re-export types for convenience
+export { TelemetryErrorType, TelemetryErrorContext } from './telemetry-types';
+
+export class TelemetryError extends Error {
+  public readonly type: TelemetryErrorType;
+  public readonly context?: Record<string, any>;
+  public readonly timestamp: number;
+  public readonly retryable: boolean;
+
+  constructor(
+    type: TelemetryErrorType,
+    message: string,
+    context?: Record<string, any>,
+    retryable: boolean = false
+  ) {
+    super(message);
+    this.name = 'TelemetryError';
+    this.type = type;
+    this.context = context;
+    this.timestamp = Date.now();
+    this.retryable = retryable;
+
+    // Ensure proper prototype chain
+    Object.setPrototypeOf(this, TelemetryError.prototype);
+  }
+
+  /**
+   * Convert error to context object
+   */
+  toContext(): TelemetryErrorContext {
+    return {
+      type: this.type,
+      message: this.message,
+      context: this.context,
+      timestamp: this.timestamp,
+      retryable: this.retryable
+    };
+  }
+
+  /**
+   * Log the error with appropriate level
+   */
+  log(): void {
+    const logContext = {
+      type: this.type,
+      message: this.message,
+      ...this.context
+    };
+
+    if (this.retryable) {
+      logger.debug('Retryable telemetry error:', logContext);
+    } else {
+      logger.debug('Non-retryable telemetry error:', logContext);
+    }
+  }
+}
+
+/**
+ * Circuit Breaker for handling repeated failures
+ */
+export class TelemetryCircuitBreaker {
+  private failureCount: number = 0;
+  private lastFailureTime: number = 0;
+  private state: 'closed' | 'open' | 'half-open' = 'closed';
+
+  private readonly failureThreshold: number;
+  private readonly resetTimeout: number;
+  private readonly halfOpenRequests: number;
+  private halfOpenCount: number = 0;
+
+  constructor(
+    failureThreshold: number = 5,
+    resetTimeout: number = 60000, // 1 minute
+    halfOpenRequests: number = 3
+  ) {
+    this.failureThreshold = failureThreshold;
+    this.resetTimeout = resetTimeout;
+    this.halfOpenRequests = halfOpenRequests;
+  }
+
+  /**
+   * Check if requests should be allowed
+   */
+  shouldAllow(): boolean {
+    const now = Date.now();
+
+    switch (this.state) {
+      case 'closed':
+        return true;
+
+      case 'open':
+        // Check if enough time has passed to try half-open
+        if (now - this.lastFailureTime > this.resetTimeout) {
+          this.state = 'half-open';
+          this.halfOpenCount = 0;
+          logger.debug('Circuit breaker transitioning to half-open');
+          return true;
+        }
+        return false;
+
+      case 'half-open':
+        // Allow limited requests in half-open state
+        if (this.halfOpenCount < this.halfOpenRequests) {
+          this.halfOpenCount++;
+          return true;
+        }
+        return false;
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Record a success
+   */
+  recordSuccess(): void {
+    if (this.state === 'half-open') {
+      // If we've had enough successful requests, close the circuit
+      if (this.halfOpenCount >= this.halfOpenRequests) {
+        this.state = 'closed';
+        this.failureCount = 0;
+        logger.debug('Circuit breaker closed after successful recovery');
+      }
+    } else if (this.state === 'closed') {
+      // Reset failure count on success
+      this.failureCount = 0;
+    }
+  }
+
+  /**
+   * Record a failure
+   */
+  recordFailure(error?: Error): void {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+
+    if (this.state === 'half-open') {
+      // Immediately open on failure in half-open state
+      this.state = 'open';
+      logger.debug('Circuit breaker opened from half-open state', { error: error?.message });
+    } else if (this.state === 'closed' && this.failureCount >= this.failureThreshold) {
+      // Open circuit after threshold reached
+      this.state = 'open';
+      logger.debug(
+        `Circuit breaker opened after ${this.failureCount} failures`,
+        { error: error?.message }
+      );
+    }
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): { state: string; failureCount: number; canRetry: boolean } {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      canRetry: this.shouldAllow()
+    };
+  }
+
+  /**
+   * Force reset the circuit breaker
+   */
+  reset(): void {
+    this.state = 'closed';
+    this.failureCount = 0;
+    this.lastFailureTime = 0;
+    this.halfOpenCount = 0;
+  }
+}
+
+/**
+ * Error aggregator for tracking error patterns
+ */
+export class TelemetryErrorAggregator {
+  private errors: Map<TelemetryErrorType, number> = new Map();
+  private errorDetails: TelemetryErrorContext[] = [];
+  private readonly maxDetails: number = 100;
+
+  /**
+   * Record an error
+   */
+  record(error: TelemetryError): void {
+    // Increment counter for this error type
+    const count = this.errors.get(error.type) || 0;
+    this.errors.set(error.type, count + 1);
+
+    // Store error details (limited)
+    this.errorDetails.push(error.toContext());
+    if (this.errorDetails.length > this.maxDetails) {
+      this.errorDetails.shift();
+    }
+  }
+
+  /**
+   * Get error statistics
+   */
+  getStats(): {
+    totalErrors: number;
+    errorsByType: Record<string, number>;
+    mostCommonError?: string;
+    recentErrors: TelemetryErrorContext[];
+  } {
+    const errorsByType: Record<string, number> = {};
+    let totalErrors = 0;
+    let mostCommonError: string | undefined;
+    let maxCount = 0;
+
+    for (const [type, count] of this.errors.entries()) {
+      errorsByType[type] = count;
+      totalErrors += count;
+
+      if (count > maxCount) {
+        maxCount = count;
+        mostCommonError = type;
+      }
+    }
+
+    return {
+      totalErrors,
+      errorsByType,
+      mostCommonError,
+      recentErrors: this.errorDetails.slice(-10) // Last 10 errors
+    };
+  }
+
+  /**
+   * Clear error history
+   */
+  reset(): void {
+    this.errors.clear();
+    this.errorDetails = [];
+  }
+}

src/telemetry/telemetry-manager.ts

@@ -0,0 +1,316 @@
+/**
+ * Telemetry Manager
+ * Main telemetry coordinator using modular components
+ */
+
+import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { TelemetryConfigManager } from './config-manager';
+import { TelemetryEventTracker } from './event-tracker';
+import { TelemetryBatchProcessor } from './batch-processor';
+import { TelemetryPerformanceMonitor } from './performance-monitor';
+import { TELEMETRY_BACKEND } from './telemetry-types';
+import { TelemetryError, TelemetryErrorType, TelemetryErrorAggregator } from './telemetry-error';
+import { logger } from '../utils/logger';
+
+export class TelemetryManager {
+  private static instance: TelemetryManager;
+  private supabase: SupabaseClient | null = null;
+  private configManager: TelemetryConfigManager;
+  private eventTracker: TelemetryEventTracker;
+  private batchProcessor: TelemetryBatchProcessor;
+  private performanceMonitor: TelemetryPerformanceMonitor;
+  private errorAggregator: TelemetryErrorAggregator;
+  private isInitialized: boolean = false;
+
+  private constructor() {
+    // Prevent direct instantiation even when TypeScript is bypassed
+    if (TelemetryManager.instance) {
+      throw new Error('Use TelemetryManager.getInstance() instead of new TelemetryManager()');
+    }
+
+    this.configManager = TelemetryConfigManager.getInstance();
+    this.errorAggregator = new TelemetryErrorAggregator();
+    this.performanceMonitor = new TelemetryPerformanceMonitor();
+
+    // Initialize event tracker with callbacks
+    this.eventTracker = new TelemetryEventTracker(
+      () => this.configManager.getUserId(),
+      () => this.isEnabled()
+    );
+
+    // Initialize batch processor (will be configured after Supabase init)
+    this.batchProcessor = new TelemetryBatchProcessor(
+      null,
+      () => this.isEnabled()
+    );
+
+    // Delay initialization to first use, not constructor
+    // this.initialize();
+  }
+
+  static getInstance(): TelemetryManager {
+    if (!TelemetryManager.instance) {
+      TelemetryManager.instance = new TelemetryManager();
+    }
+    return TelemetryManager.instance;
+  }
+
+  /**
+   * Ensure telemetry is initialized before use
+   */
+  private ensureInitialized(): void {
+    if (!this.isInitialized && this.configManager.isEnabled()) {
+      this.initialize();
+    }
+  }
+
+  /**
+   * Initialize telemetry if enabled
+   */
+  private initialize(): void {
+    if (!this.configManager.isEnabled()) {
+      logger.debug('Telemetry disabled by user preference');
+      return;
+    }
+
+    // Use hardcoded credentials for zero-configuration telemetry
+    // Environment variables can override for development/testing
+    const supabaseUrl = process.env.SUPABASE_URL || TELEMETRY_BACKEND.URL;
+    const supabaseAnonKey = process.env.SUPABASE_ANON_KEY || TELEMETRY_BACKEND.ANON_KEY;
+
+    try {
+      this.supabase = createClient(supabaseUrl, supabaseAnonKey, {
+        auth: {
+          persistSession: false,
+          autoRefreshToken: false,
+        },
+        realtime: {
+          params: {
+            eventsPerSecond: 1,
+          },
+        },
+      });
+
+      // Update batch processor with Supabase client
+      this.batchProcessor = new TelemetryBatchProcessor(
+        this.supabase,
+        () => this.isEnabled()
+      );
+
+      this.batchProcessor.start();
+      this.isInitialized = true;
+
+      logger.debug('Telemetry initialized successfully');
+    } catch (error) {
+      const telemetryError = new TelemetryError(
+        TelemetryErrorType.INITIALIZATION_ERROR,
+        'Failed to initialize telemetry',
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+      this.errorAggregator.record(telemetryError);
+      telemetryError.log();
+      this.isInitialized = false;
+    }
+  }
+
+  /**
+   * Track a tool usage event
+   */
+  trackToolUsage(toolName: string, success: boolean, duration?: number): void {
+    this.ensureInitialized();
+    this.performanceMonitor.startOperation('trackToolUsage');
+    this.eventTracker.trackToolUsage(toolName, success, duration);
+    this.eventTracker.updateToolSequence(toolName);
+    this.performanceMonitor.endOperation('trackToolUsage');
+  }
+
+  /**
+   * Track workflow creation
+   */
+  async trackWorkflowCreation(workflow: any, validationPassed: boolean): Promise<void> {
+    this.ensureInitialized();
+    this.performanceMonitor.startOperation('trackWorkflowCreation');
+    try {
+      await this.eventTracker.trackWorkflowCreation(workflow, validationPassed);
+      // Auto-flush workflows to prevent data loss
+      await this.flush();
+    } catch (error) {
+      const telemetryError = error instanceof TelemetryError
+        ? error
+        : new TelemetryError(
+            TelemetryErrorType.UNKNOWN_ERROR,
+            'Failed to track workflow',
+            { error: String(error) }
+          );
+      this.errorAggregator.record(telemetryError);
+    } finally {
+      this.performanceMonitor.endOperation('trackWorkflowCreation');
+    }
+  }
+
+
+  /**
+   * Track an error event
+   */
+  trackError(errorType: string, context: string, toolName?: string, errorMessage?: string): void {
+    this.ensureInitialized();
+    this.eventTracker.trackError(errorType, context, toolName, errorMessage);
+  }
+
+  /**
+   * Track a generic event
+   */
+  trackEvent(eventName: string, properties: Record<string, any>): void {
+    this.ensureInitialized();
+    this.eventTracker.trackEvent(eventName, properties);
+  }
+
+  /**
+   * Track session start
+   */
+  trackSessionStart(): void {
+    this.ensureInitialized();
+    this.eventTracker.trackSessionStart();
+  }
+
+  /**
+   * Track search queries
+   */
+  trackSearchQuery(query: string, resultsFound: number, searchType: string): void {
+    this.eventTracker.trackSearchQuery(query, resultsFound, searchType);
+  }
+
+  /**
+   * Track validation details
+   */
+  trackValidationDetails(nodeType: string, errorType: string, details: Record<string, any>): void {
+    this.eventTracker.trackValidationDetails(nodeType, errorType, details);
+  }
+
+  /**
+   * Track tool sequences
+   */
+  trackToolSequence(previousTool: string, currentTool: string, timeDelta: number): void {
+    this.eventTracker.trackToolSequence(previousTool, currentTool, timeDelta);
+  }
+
+  /**
+   * Track node configuration
+   */
+  trackNodeConfiguration(nodeType: string, propertiesSet: number, usedDefaults: boolean): void {
+    this.eventTracker.trackNodeConfiguration(nodeType, propertiesSet, usedDefaults);
+  }
+
+  /**
+   * Track performance metrics
+   */
+  trackPerformanceMetric(operation: string, duration: number, metadata?: Record<string, any>): void {
+    this.eventTracker.trackPerformanceMetric(operation, duration, metadata);
+  }
+
+
+  /**
+   * Flush queued events to Supabase
+   */
+  async flush(): Promise<void> {
+    this.ensureInitialized();
+    if (!this.isEnabled() || !this.supabase) return;
+
+    this.performanceMonitor.startOperation('flush');
+
+    // Get queued data from event tracker
+    const events = this.eventTracker.getEventQueue();
+    const workflows = this.eventTracker.getWorkflowQueue();
+
+    // Clear queues immediately to prevent duplicate processing
+    this.eventTracker.clearEventQueue();
+    this.eventTracker.clearWorkflowQueue();
+
+    try {
+      // Use batch processor to flush
+      await this.batchProcessor.flush(events, workflows);
+    } catch (error) {
+      const telemetryError = error instanceof TelemetryError
+        ? error
+        : new TelemetryError(
+            TelemetryErrorType.NETWORK_ERROR,
+            'Failed to flush telemetry',
+            { error: String(error) },
+            true // Retryable
+          );
+      this.errorAggregator.record(telemetryError);
+      telemetryError.log();
+    } finally {
+      const duration = this.performanceMonitor.endOperation('flush');
+      if (duration > 100) {
+        logger.debug(`Telemetry flush took ${duration.toFixed(2)}ms`);
+      }
+    }
+  }
+
+
+  /**
+   * Check if telemetry is enabled
+   */
+  private isEnabled(): boolean {
+    return this.isInitialized && this.configManager.isEnabled();
+  }
+
+  /**
+   * Disable telemetry
+   */
+  disable(): void {
+    this.configManager.disable();
+    this.batchProcessor.stop();
+    this.isInitialized = false;
+    this.supabase = null;
+  }
+
+  /**
+   * Enable telemetry
+   */
+  enable(): void {
+    this.configManager.enable();
+    this.initialize();
+  }
+
+  /**
+   * Get telemetry status
+   */
+  getStatus(): string {
+    return this.configManager.getStatus();
+  }
+
+  /**
+   * Get comprehensive telemetry metrics
+   */
+  getMetrics() {
+    return {
+      status: this.isEnabled() ? 'enabled' : 'disabled',
+      initialized: this.isInitialized,
+      tracking: this.eventTracker.getStats(),
+      processing: this.batchProcessor.getMetrics(),
+      errors: this.errorAggregator.getStats(),
+      performance: this.performanceMonitor.getDetailedReport(),
+      overhead: this.performanceMonitor.getTelemetryOverhead()
+    };
+  }
+
+  /**
+   * Reset singleton instance (for testing purposes)
+   */
+  static resetInstance(): void {
+    TelemetryManager.instance = undefined as any;
+    (global as any).__telemetryManager = undefined;
+  }
+}
+
+// Create a global singleton to ensure only one instance across all imports
+const globalAny = global as any;
+
+if (!globalAny.__telemetryManager) {
+  globalAny.__telemetryManager = TelemetryManager.getInstance();
+}
+
+// Export singleton instance
+export const telemetry = globalAny.__telemetryManager as TelemetryManager;

src/telemetry/telemetry-types.ts

@@ -0,0 +1,87 @@
+/**
+ * Telemetry Types and Interfaces
+ * Centralized type definitions for the telemetry system
+ */
+
+export interface TelemetryEvent {
+  user_id: string;
+  event: string;
+  properties: Record<string, any>;
+  created_at?: string;
+}
+
+export interface WorkflowTelemetry {
+  user_id: string;
+  workflow_hash: string;
+  node_count: number;
+  node_types: string[];
+  has_trigger: boolean;
+  has_webhook: boolean;
+  complexity: 'simple' | 'medium' | 'complex';
+  sanitized_workflow: any;
+  created_at?: string;
+}
+
+export interface SanitizedWorkflow {
+  nodes: any[];
+  connections: any;
+  nodeCount: number;
+  nodeTypes: string[];
+  hasTrigger: boolean;
+  hasWebhook: boolean;
+  complexity: 'simple' | 'medium' | 'complex';
+  workflowHash: string;
+}
+
+export const TELEMETRY_CONFIG = {
+  // Batch processing
+  BATCH_FLUSH_INTERVAL: 5000, // 5 seconds
+  EVENT_QUEUE_THRESHOLD: 10, // Batch events for efficiency
+  WORKFLOW_QUEUE_THRESHOLD: 5, // Batch workflows
+
+  // Retry logic
+  MAX_RETRIES: 3,
+  RETRY_DELAY: 1000, // 1 second base delay
+  OPERATION_TIMEOUT: 5000, // 5 seconds
+
+  // Rate limiting
+  RATE_LIMIT_WINDOW: 60000, // 1 minute
+  RATE_LIMIT_MAX_EVENTS: 100, // Max events per window
+
+  // Queue limits
+  MAX_QUEUE_SIZE: 1000, // Maximum events to queue
+  MAX_BATCH_SIZE: 50, // Maximum events per batch
+} as const;
+
+export const TELEMETRY_BACKEND = {
+  URL: 'https://ydyufsohxdfpopqbubwk.supabase.co',
+  ANON_KEY: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InlkeXVmc29oeGRmcG9wcWJ1YndrIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTg3OTYyMDAsImV4cCI6MjA3NDM3MjIwMH0.xESphg6h5ozaDsm4Vla3QnDJGc6Nc_cpfoqTHRynkCk'
+} as const;
+
+export interface TelemetryMetrics {
+  eventsTracked: number;
+  eventsDropped: number;
+  eventsFailed: number;
+  batchesSent: number;
+  batchesFailed: number;
+  averageFlushTime: number;
+  lastFlushTime?: number;
+  rateLimitHits: number;
+}
+
+export enum TelemetryErrorType {
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  RATE_LIMIT_ERROR = 'RATE_LIMIT_ERROR',
+  QUEUE_OVERFLOW_ERROR = 'QUEUE_OVERFLOW_ERROR',
+  INITIALIZATION_ERROR = 'INITIALIZATION_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR'
+}
+
+export interface TelemetryErrorContext {
+  type: TelemetryErrorType;
+  message: string;
+  context?: Record<string, any>;
+  timestamp: number;
+  retryable: boolean;
+}

src/telemetry/workflow-sanitizer.ts

@@ -0,0 +1,299 @@
+/**
+ * Workflow Sanitizer
+ * Removes sensitive data from workflows before telemetry storage
+ */
+
+import { createHash } from 'crypto';
+
+interface WorkflowNode {
+  id: string;
+  name: string;
+  type: string;
+  position: [number, number];
+  parameters: any;
+  credentials?: any;
+  disabled?: boolean;
+  typeVersion?: number;
+}
+
+interface SanitizedWorkflow {
+  nodes: WorkflowNode[];
+  connections: any;
+  nodeCount: number;
+  nodeTypes: string[];
+  hasTrigger: boolean;
+  hasWebhook: boolean;
+  complexity: 'simple' | 'medium' | 'complex';
+  workflowHash: string;
+}
+
+export class WorkflowSanitizer {
+  private static readonly SENSITIVE_PATTERNS = [
+    // Webhook URLs (replace with placeholder but keep structure) - MUST BE FIRST
+    /https?:\/\/[^\s/]+\/webhook\/[^\s]+/g,
+    /https?:\/\/[^\s/]+\/hook\/[^\s]+/g,
+
+    // API keys and tokens
+    /sk-[a-zA-Z0-9]{16,}/g, // OpenAI keys
+    /Bearer\s+[^\s]+/gi,    // Bearer tokens
+    /[a-zA-Z0-9_-]{20,}/g,  // Long alphanumeric strings (API keys) - reduced threshold
+    /token['":\s]+[^,}]+/gi, // Token fields
+    /apikey['":\s]+[^,}]+/gi, // API key fields
+    /api_key['":\s]+[^,}]+/gi,
+    /secret['":\s]+[^,}]+/gi,
+    /password['":\s]+[^,}]+/gi,
+    /credential['":\s]+[^,}]+/gi,
+
+    // URLs with authentication
+    /https?:\/\/[^:]+:[^@]+@[^\s/]+/g, // URLs with auth
+    /wss?:\/\/[^:]+:[^@]+@[^\s/]+/g,
+
+    // Email addresses (optional - uncomment if needed)
+    // /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+  ];
+
+  private static readonly SENSITIVE_FIELDS = [
+    'apiKey',
+    'api_key',
+    'token',
+    'secret',
+    'password',
+    'credential',
+    'auth',
+    'authorization',
+    'webhook',
+    'webhookUrl',
+    'url',
+    'endpoint',
+    'host',
+    'server',
+    'database',
+    'connectionString',
+    'privateKey',
+    'publicKey',
+    'certificate',
+  ];
+
+  /**
+   * Sanitize a complete workflow
+   */
+  static sanitizeWorkflow(workflow: any): SanitizedWorkflow {
+    // Create a deep copy to avoid modifying original
+    const sanitized = JSON.parse(JSON.stringify(workflow));
+
+    // Sanitize nodes
+    if (sanitized.nodes && Array.isArray(sanitized.nodes)) {
+      sanitized.nodes = sanitized.nodes.map((node: WorkflowNode) =>
+        this.sanitizeNode(node)
+      );
+    }
+
+    // Sanitize connections (keep structure only)
+    if (sanitized.connections) {
+      sanitized.connections = this.sanitizeConnections(sanitized.connections);
+    }
+
+    // Remove other potentially sensitive data
+    delete sanitized.settings?.errorWorkflow;
+    delete sanitized.staticData;
+    delete sanitized.pinData;
+    delete sanitized.credentials;
+    delete sanitized.sharedWorkflows;
+    delete sanitized.ownedBy;
+    delete sanitized.createdBy;
+    delete sanitized.updatedBy;
+
+    // Calculate metrics
+    const nodeTypes = sanitized.nodes?.map((n: WorkflowNode) => n.type) || [];
+    const uniqueNodeTypes = [...new Set(nodeTypes)] as string[];
+
+    const hasTrigger = nodeTypes.some((type: string) =>
+      type.includes('trigger') || type.includes('webhook')
+    );
+
+    const hasWebhook = nodeTypes.some((type: string) =>
+      type.includes('webhook')
+    );
+
+    // Calculate complexity
+    const nodeCount = sanitized.nodes?.length || 0;
+    let complexity: 'simple' | 'medium' | 'complex' = 'simple';
+    if (nodeCount > 20) {
+      complexity = 'complex';
+    } else if (nodeCount > 10) {
+      complexity = 'medium';
+    }
+
+    // Generate workflow hash (for deduplication)
+    const workflowStructure = JSON.stringify({
+      nodeTypes: uniqueNodeTypes.sort(),
+      connections: sanitized.connections
+    });
+    const workflowHash = createHash('sha256')
+      .update(workflowStructure)
+      .digest('hex')
+      .substring(0, 16);
+
+    return {
+      nodes: sanitized.nodes || [],
+      connections: sanitized.connections || {},
+      nodeCount,
+      nodeTypes: uniqueNodeTypes,
+      hasTrigger,
+      hasWebhook,
+      complexity,
+      workflowHash
+    };
+  }
+
+  /**
+   * Sanitize a single node
+   */
+  private static sanitizeNode(node: WorkflowNode): WorkflowNode {
+    const sanitized = { ...node };
+
+    // Remove credentials entirely
+    delete sanitized.credentials;
+
+    // Sanitize parameters
+    if (sanitized.parameters) {
+      sanitized.parameters = this.sanitizeObject(sanitized.parameters);
+    }
+
+    return sanitized;
+  }
+
+  /**
+   * Recursively sanitize an object
+   */
+  private static sanitizeObject(obj: any): any {
+    if (!obj || typeof obj !== 'object') {
+      return obj;
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.sanitizeObject(item));
+    }
+
+    const sanitized: any = {};
+
+    for (const [key, value] of Object.entries(obj)) {
+      // Check if key is sensitive
+      if (this.isSensitiveField(key)) {
+        sanitized[key] = '[REDACTED]';
+        continue;
+      }
+
+      // Recursively sanitize nested objects
+      if (typeof value === 'object' && value !== null) {
+        sanitized[key] = this.sanitizeObject(value);
+      }
+      // Sanitize string values
+      else if (typeof value === 'string') {
+        sanitized[key] = this.sanitizeString(value, key);
+      }
+      // Keep other types as-is
+      else {
+        sanitized[key] = value;
+      }
+    }
+
+    return sanitized;
+  }
+
+  /**
+   * Sanitize string values
+   */
+  private static sanitizeString(value: string, fieldName: string): string {
+    // First check if this is a webhook URL
+    if (value.includes('/webhook/') || value.includes('/hook/')) {
+      return 'https://[webhook-url]';
+    }
+
+    let sanitized = value;
+
+    // Apply all sensitive patterns
+    for (const pattern of this.SENSITIVE_PATTERNS) {
+      // Skip webhook patterns - already handled above
+      if (pattern.toString().includes('webhook')) {
+        continue;
+      }
+      sanitized = sanitized.replace(pattern, '[REDACTED]');
+    }
+
+    // Additional sanitization for specific field types
+    if (fieldName.toLowerCase().includes('url') ||
+        fieldName.toLowerCase().includes('endpoint')) {
+      // Keep URL structure but remove domain details
+      if (sanitized.startsWith('http://') || sanitized.startsWith('https://')) {
+        // If value has been redacted, leave it as is
+        if (sanitized.includes('[REDACTED]')) {
+          return '[REDACTED]';
+        }
+        const urlParts = sanitized.split('/');
+        if (urlParts.length > 2) {
+          urlParts[2] = '[domain]';
+          sanitized = urlParts.join('/');
+        }
+      }
+    }
+
+    return sanitized;
+  }
+
+  /**
+   * Check if a field name is sensitive
+   */
+  private static isSensitiveField(fieldName: string): boolean {
+    const lowerFieldName = fieldName.toLowerCase();
+    return this.SENSITIVE_FIELDS.some(sensitive =>
+      lowerFieldName.includes(sensitive.toLowerCase())
+    );
+  }
+
+  /**
+   * Sanitize connections (keep structure only)
+   */
+  private static sanitizeConnections(connections: any): any {
+    if (!connections || typeof connections !== 'object') {
+      return connections;
+    }
+
+    const sanitized: any = {};
+
+    for (const [nodeId, nodeConnections] of Object.entries(connections)) {
+      if (typeof nodeConnections === 'object' && nodeConnections !== null) {
+        sanitized[nodeId] = {};
+
+        for (const [connType, connArray] of Object.entries(nodeConnections as any)) {
+          if (Array.isArray(connArray)) {
+            sanitized[nodeId][connType] = connArray.map((conns: any) => {
+              if (Array.isArray(conns)) {
+                return conns.map((conn: any) => ({
+                  node: conn.node,
+                  type: conn.type,
+                  index: conn.index
+                }));
+              }
+              return conns;
+            });
+          } else {
+            sanitized[nodeId][connType] = connArray;
+          }
+        }
+      } else {
+        sanitized[nodeId] = nodeConnections;
+      }
+    }
+
+    return sanitized;
+  }
+
+  /**
+   * Generate a hash for workflow deduplication
+   */
+  static generateWorkflowHash(workflow: any): string {
+    const sanitized = this.sanitizeWorkflow(workflow);
+    return sanitized.workflowHash;
+  }
+}

src/templates/batch-processor.ts

@@ -258,85 +258,132 @@ export class BatchProcessor {
   }
   
   /**
-   * Monitor batch job with exponential backoff
+   * Monitor batch job with fixed 1-minute polling interval
    */
   private async monitorBatchJob(batchId: string): Promise<any> {
-    // Start with shorter wait times for better UX
-    const waitTimes = [30, 60, 120, 300, 600, 900, 1800]; // Progressive wait times in seconds
-    let waitIndex = 0;
+    const pollInterval = 60; // Check every 60 seconds (1 minute)
     let attempts = 0;
-    const maxAttempts = 100; // Safety limit
+    const maxAttempts = 120; // 120 minutes max (2 hours)
     const startTime = Date.now();
     let lastStatus = '';
-    
+
     while (attempts < maxAttempts) {
       const batchJob = await this.client.batches.retrieve(batchId);
-      
-      // Only log if status changed
+      const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
+
+      // Log status on every check (not just on change)
+      const statusSymbol = batchJob.status === 'in_progress' ? '⚙️' :
+                          batchJob.status === 'finalizing' ? '📦' :
+                          batchJob.status === 'validating' ? '🔍' :
+                          batchJob.status === 'completed' ? '✅' :
+                          batchJob.status === 'failed' ? '❌' : '⏳';
+
+      console.log(`   ${statusSymbol} Batch ${batchId.slice(-8)}: ${batchJob.status} (${elapsedMinutes} min, check ${attempts + 1})`);
+
       if (batchJob.status !== lastStatus) {
-        const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
-        const statusSymbol = batchJob.status === 'in_progress' ? '⚙️' : 
-                            batchJob.status === 'finalizing' ? '📦' :
-                            batchJob.status === 'validating' ? '🔍' : '⏳';
-        
-        console.log(`   ${statusSymbol} Batch ${batchId.slice(-8)}: ${batchJob.status} (${elapsedMinutes} min)`);
+        logger.info(`Batch ${batchId} status changed: ${lastStatus} -> ${batchJob.status}`);
         lastStatus = batchJob.status;
       }
-      
-      logger.debug(`Batch ${batchId} status: ${batchJob.status} (attempt ${attempts + 1})`);
-      
+
       if (batchJob.status === 'completed') {
-        const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
-        console.log(`   ✅ Batch ${batchId.slice(-8)} completed in ${elapsedMinutes} minutes`);
+        console.log(`   ✅ Batch ${batchId.slice(-8)} completed successfully in ${elapsedMinutes} minutes`);
         logger.info(`Batch job ${batchId} completed successfully`);
         return batchJob;
       }
-      
+
       if (['failed', 'expired', 'cancelled'].includes(batchJob.status)) {
+        logger.error(`Batch job ${batchId} failed with status: ${batchJob.status}`);
         throw new Error(`Batch job failed with status: ${batchJob.status}`);
       }
-      
-      // Wait before next check
-      const waitTime = waitTimes[Math.min(waitIndex, waitTimes.length - 1)];
-      logger.debug(`Waiting ${waitTime} seconds before next check...`);
-      await this.sleep(waitTime * 1000);
-      
-      waitIndex = Math.min(waitIndex + 1, waitTimes.length - 1);
+
+      // Wait before next check (always 1 minute)
+      logger.debug(`Waiting ${pollInterval} seconds before next check...`);
+      await this.sleep(pollInterval * 1000);
+
       attempts++;
     }
-    
-    throw new Error(`Batch job monitoring timed out after ${maxAttempts} attempts`);
+
+    throw new Error(`Batch job monitoring timed out after ${maxAttempts} minutes`);
   }
   
   /**
    * Retrieve and parse results
    */
   private async retrieveResults(batchJob: any): Promise<MetadataResult[]> {
-    if (!batchJob.output_file_id) {
-      throw new Error('No output file available for batch job');
-    }
-    
-    // Download result file
-    const fileResponse = await this.client.files.content(batchJob.output_file_id);
-    const fileContent = await fileResponse.text();
-    
-    // Parse JSONL results
     const results: MetadataResult[] = [];
-    const lines = fileContent.trim().split('\n');
-    
-    for (const line of lines) {
-      if (!line) continue;
-      
+
+    // Check if we have an output file (successful results)
+    if (batchJob.output_file_id) {
+      const fileResponse = await this.client.files.content(batchJob.output_file_id);
+      const fileContent = await fileResponse.text();
+
+      const lines = fileContent.trim().split('\n');
+      for (const line of lines) {
+        if (!line) continue;
+        try {
+          const result = JSON.parse(line);
+          const parsed = this.generator.parseResult(result);
+          results.push(parsed);
+        } catch (error) {
+          logger.error('Error parsing result line:', error);
+        }
+      }
+      logger.info(`Retrieved ${results.length} successful results from batch job`);
+    }
+
+    // Check if we have an error file (failed results)
+    if (batchJob.error_file_id) {
+      logger.warn(`Batch job has error file: ${batchJob.error_file_id}`);
+
       try {
-        const result = JSON.parse(line);
-        const parsed = this.generator.parseResult(result);
-        results.push(parsed);
+        const errorResponse = await this.client.files.content(batchJob.error_file_id);
+        const errorContent = await errorResponse.text();
+
+        // Save error file locally for debugging
+        const errorFilePath = path.join(this.outputDir, `batch_${batchJob.id}_error.jsonl`);
+        fs.writeFileSync(errorFilePath, errorContent);
+        logger.warn(`Error file saved to: ${errorFilePath}`);
+
+        // Parse errors and create default metadata for failed templates
+        const errorLines = errorContent.trim().split('\n');
+        logger.warn(`Found ${errorLines.length} failed requests in error file`);
+
+        for (const line of errorLines) {
+          if (!line) continue;
+          try {
+            const errorResult = JSON.parse(line);
+            const templateId = parseInt(errorResult.custom_id?.replace('template-', '') || '0');
+
+            if (templateId > 0) {
+              const errorMessage = errorResult.response?.body?.error?.message ||
+                                  errorResult.error?.message ||
+                                  'Unknown error';
+
+              logger.debug(`Template ${templateId} failed: ${errorMessage}`);
+
+              // Use getDefaultMetadata() from generator (it's private but accessible via bracket notation)
+              const defaultMeta = (this.generator as any).getDefaultMetadata();
+              results.push({
+                templateId,
+                metadata: defaultMeta,
+                error: errorMessage
+              });
+            }
+          } catch (parseError) {
+            logger.error('Error parsing error line:', parseError);
+          }
+        }
       } catch (error) {
-        logger.error('Error parsing result line:', error);
+        logger.error('Failed to process error file:', error);
       }
     }
-    
-    logger.info(`Retrieved ${results.length} results from batch job`);
+
+    // If we have no results at all, something is very wrong
+    if (results.length === 0 && !batchJob.output_file_id && !batchJob.error_file_id) {
+      throw new Error('No output file or error file available for batch job');
+    }
+
+    logger.info(`Total results (successful + failed): ${results.length}`);
     return results;
   }
   

src/templates/metadata-generator.ts

@@ -34,7 +34,7 @@ export class MetadataGenerator {
   private client: OpenAI;
   private model: string;
   
-  constructor(apiKey: string, model: string = 'gpt-4o-mini') {
+  constructor(apiKey: string, model: string = 'gpt-5-mini-2025-08-07') {
     this.client = new OpenAI({ apiKey });
     this.model = model;
   }
@@ -131,8 +131,8 @@ export class MetadataGenerator {
       url: '/v1/chat/completions',
       body: {
         model: this.model,
-        temperature: 0.3,  // Lower temperature for more consistent structured outputs
-        max_completion_tokens: 1000,
+        // temperature removed - batch API only supports default (1.0) for this model
+        max_completion_tokens: 3000,
         response_format: {
           type: 'json_schema',
           json_schema: this.getJsonSchema()
@@ -288,8 +288,8 @@ export class MetadataGenerator {
     try {
       const completion = await this.client.chat.completions.create({
         model: this.model,
-        temperature: 0.3,  // Lower temperature for more consistent structured outputs
-        max_completion_tokens: 1000,
+        // temperature removed - not supported in batch API for this model
+        max_completion_tokens: 3000,
         response_format: {
           type: 'json_schema',
           json_schema: this.getJsonSchema()