Merge pull request #243 from czlonkowski/feature/execution-data-filtering

feat: Intelligent Execution Data Filtering for n8n_get_execution Tool

.gitignore

@@ -89,6 +89,10 @@ docker-compose.override.yml
 temp/
 tmp/
 
+# Batch processing error files (may contain API tokens from templates)
+docs/batch_*.jsonl
+**/batch_*_error.jsonl
+
 # Database files
 # Database files - nodes.db is now tracked directly
 # data/*.db

CHANGELOG.md

@@ -5,6 +5,178 @@ 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.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

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

README.md

@@ -4,8 +4,8 @@
 [![GitHub stars](https://img.shields.io/github/stars/czlonkowski/n8n-mcp?style=social)](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.112.3-orange.svg)](https://github.com/n8n-io/n8n)
+[![Tests](https://img.shields.io/badge/tests-2883%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)
 
@@ -817,7 +817,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
@@ -837,9 +837,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

docs/CHANGELOG.md

@@ -5,6 +5,57 @@ 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.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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.14.1",
+  "version": "2.14.5",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "bin": {
@@ -37,6 +37,7 @@
     "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: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,14 +129,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.2",
-    "@n8n/n8n-nodes-langchain": "^1.111.1",
+    "@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.112.3",
-    "n8n-core": "^1.111.0",
-    "n8n-workflow": "^1.109.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,6 +1,6 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.14.0",
+  "version": "2.14.4",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "dependencies": {

src/database/node-repository.ts

@@ -377,4 +377,78 @@ export class NodeRepository {
 
     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/mcp/handlers-n8n-manager.ts

@@ -6,7 +6,9 @@ import {
   WorkflowConnection,
   ExecutionStatus,
   WebhookRequest,
-  McpToolResponse
+  McpToolResponse,
+  ExecutionFilterOptions,
+  ExecutionMode
 } from '../types/n8n-api';
 import {
   validateWorkflowStructure,
@@ -36,6 +38,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;
@@ -983,16 +986,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) {
@@ -1002,7 +1061,7 @@ export async function handleGetExecution(args: unknown, context?: InstanceContex
         details: { errors: error.errors }
       };
     }
-    
+
     if (error instanceof N8nApiError) {
       return {
         success: false,
@@ -1010,7 +1069,7 @@ export async function handleGetExecution(args: unknown, context?: InstanceContex
         code: error.code
       };
     }
-    
+
     return {
       success: false,
       error: error instanceof Error ? error.message : 'Unknown error occurred'

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/server.ts

@@ -2659,24 +2659,19 @@ 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;

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[];
@@ -24,6 +24,7 @@ export interface ToolDocumentation {
     performance: string;
     bestPractices: string[];
     pitfalls: string[];
+    modeComparison?: string; // Optional: Comparison of different modes for tools with multiple modes
     relatedTools: string[];
   };
 }

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-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. 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 multiple operations in one call',
+      '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.
+    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,51 +28,77 @@ 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. 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})'
+      '// Clean up stale connections after node renames/deletions\nn8n_update_partial_workflow({id: "abc", operations: [{type: "cleanStaleConnections"}]})',
+      '// Remove connection gracefully (no error if it doesn\'t exist)\nn8n_update_partial_workflow({id: "xyz", operations: [{type: "removeConnection", source: "Old Node", target: "Target", ignoreErrors: true}]})',
+      '// Best-effort mode: apply what works, report what fails\nn8n_update_partial_workflow({id: "123", 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: "456", operations: [{type: "replaceConnections", connections: {"Webhook": {"main": [[{node: "Slack", type: "main", index: 0}]]}}}]})',
+      '// Update node parameter (classic atomic mode)\nn8n_update_partial_workflow({id: "789", operations: [{type: "updateNode", nodeName: "HTTP Request", updates: {"parameters.url": "https://api.example.com"}}]})',
+      '// Validate before applying\nn8n_update_partial_workflow({id: "012", 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',
-      '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',
-      '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/tools-n8n-manager.ts

@@ -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']
@@ -340,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/scripts/sanitize-templates.ts

@@ -2,32 +2,50 @@
 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) {
-      if (!template.workflow_json) {
-        continue; // Skip templates without workflow data
+      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`);
+        }
       }
 
-      let originalWorkflow;
-      try {
-        originalWorkflow = JSON.parse(template.workflow_json);
-      } catch (e) {
-        console.log(`⚠️ Skipping template ${template.id}: Invalid JSON`);
-        continue;
+      // 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);
@@ -35,18 +53,24 @@ async function sanitizeTemplates() {
       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-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/services/config-validator.ts

@@ -108,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({
@@ -133,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

@@ -12,6 +12,7 @@ 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 { normalizeNodeType } from '../utils/node-type-utils';
 
 export type ValidationMode = 'full' | 'operation' | 'minimal';
 export type ValidationProfile = 'strict' | 'runtime' | 'ai-friendly' | 'minimal';
@@ -76,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 = {
@@ -136,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;
   }
   
   /**
@@ -675,11 +701,25 @@ export class EnhancedConfigValidator extends ConfigValidator {
       return;
     }
 
+    // Normalize the node type for repository lookups
+    const normalizedNodeType = normalizeNodeType(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(nodeType);
+      const validResources = this.nodeRepository.getNodeResources(normalizedNodeType);
       const resourceIsValid = validResources.some(r => {
         const resourceValue = typeof r === 'string' ? r : r.value;
         return resourceValue === config.resource;
@@ -690,7 +730,7 @@ export class EnhancedConfigValidator extends ConfigValidator {
         let suggestions: any[] = [];
         try {
           suggestions = this.resourceSimilarityService.findSimilarResources(
-            nodeType,
+            normalizedNodeType,
             config.resource,
             3
           );
@@ -749,22 +789,27 @@ export class EnhancedConfigValidator extends ConfigValidator {
       }
     }
 
-    // Validate operation field if present
-    if (config.operation !== undefined) {
+    // 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');
-      const validOperations = this.nodeRepository.getNodeOperations(nodeType, config.resource);
+
+      // 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 === config.operation;
+        return opValue === operationToValidate;
       });
 
-      if (!operationIsValid && config.operation !== '') {
+      // 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(
-            nodeType,
+            normalizedNodeType,
             config.operation,
             config.resource,
             3

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/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/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,18 +39,18 @@ export class WorkflowDiffEngine {
    * Apply diff operations to a workflow
    */
   async applyDiff(
-    workflow: Workflow, 
+    workflow: Workflow,
     request: WorkflowDiffRequest
   ): Promise<WorkflowDiffResult> {
     try {
       // 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 });
@@ -57,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 {
@@ -170,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}`;
     }
@@ -219,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;
     }
   }
 
@@ -318,30 +388,35 @@ export class WorkflowDiffEngine {
   }
 
   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;
   }
 
@@ -504,7 +579,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];
@@ -579,6 +660,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

@@ -364,19 +364,6 @@ 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({
-            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);
 

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()

src/types/n8n-api.ts

@@ -290,4 +290,84 @@ export interface McpToolResponse {
   message?: string;
   code?: string;
   details?: Record<string, unknown>;
+}
+
+// Execution Filtering Types
+export type ExecutionMode = 'preview' | 'summary' | 'filtered' | 'full';
+
+export interface ExecutionPreview {
+  totalNodes: number;
+  executedNodes: number;
+  estimatedSizeKB: number;
+  nodes: Record<string, NodePreview>;
+}
+
+export interface NodePreview {
+  status: 'success' | 'error';
+  itemCounts: {
+    input: number;
+    output: number;
+  };
+  dataStructure: Record<string, any>;
+  estimatedSizeKB: number;
+  error?: string;
+}
+
+export interface ExecutionRecommendation {
+  canFetchFull: boolean;
+  suggestedMode: ExecutionMode;
+  suggestedItemsLimit?: number;
+  reason: string;
+}
+
+export interface ExecutionFilterOptions {
+  mode?: ExecutionMode;
+  nodeNames?: string[];
+  itemsLimit?: number;
+  includeInputData?: boolean;
+  fieldsToInclude?: string[];
+}
+
+export interface FilteredExecutionResponse {
+  id: string;
+  workflowId: string;
+  status: ExecutionStatus;
+  mode: ExecutionMode;
+  startedAt: string;
+  stoppedAt?: string;
+  duration?: number;
+  finished: boolean;
+
+  // Preview-specific data
+  preview?: ExecutionPreview;
+  recommendation?: ExecutionRecommendation;
+
+  // Summary/Filtered data
+  summary?: {
+    totalNodes: number;
+    executedNodes: number;
+    totalItems: number;
+    hasMoreData: boolean;
+  };
+  nodes?: Record<string, FilteredNodeData>;
+
+  // Error information
+  error?: Record<string, unknown>;
+}
+
+export interface FilteredNodeData {
+  executionTime?: number;
+  itemsInput: number;
+  itemsOutput: number;
+  status: 'success' | 'error';
+  error?: string;
+  data?: {
+    input?: any[][];
+    output?: any[][];
+    metadata: {
+      totalItems: number;
+      itemsShown: number;
+      truncated: boolean;
+    };
+  };
 }

src/types/workflow-diff.ts

@@ -72,6 +72,7 @@ export interface RemoveConnectionOperation extends DiffOperation {
   target: string; // Node name or ID
   sourceOutput?: string; // Default: 'main'
   targetInput?: string; // Default: 'main'
+  ignoreErrors?: boolean; // If true, don't fail when connection doesn't exist (useful for cleanup)
 }
 
 export interface UpdateConnectionOperation extends DiffOperation {
@@ -109,6 +110,25 @@ export interface RemoveTagOperation extends DiffOperation {
   tag: string;
 }
 
+// Connection Cleanup Operations
+export interface CleanStaleConnectionsOperation extends DiffOperation {
+  type: 'cleanStaleConnections';
+  dryRun?: boolean; // If true, return what would be removed without applying changes
+}
+
+export interface ReplaceConnectionsOperation extends DiffOperation {
+  type: 'replaceConnections';
+  connections: {
+    [nodeName: string]: {
+      [outputName: string]: Array<Array<{
+        node: string;
+        type: string;
+        index: number;
+      }>>;
+    };
+  };
+}
+
 // Union type for all operations
 export type WorkflowDiffOperation =
   | AddNodeOperation
@@ -123,13 +143,16 @@ export type WorkflowDiffOperation =
   | UpdateSettingsOperation
   | UpdateNameOperation
   | AddTagOperation
-  | RemoveTagOperation;
+  | RemoveTagOperation
+  | CleanStaleConnectionsOperation
+  | ReplaceConnectionsOperation;
 
 // Main diff request structure
 export interface WorkflowDiffRequest {
   id: string; // Workflow ID
   operations: WorkflowDiffOperation[];
   validateOnly?: boolean; // If true, only validate without applying
+  continueOnError?: boolean; // If true, apply valid operations even if some fail (default: false for atomic behavior)
 }
 
 // Response types
@@ -145,6 +168,9 @@ export interface WorkflowDiffResult {
   errors?: WorkflowDiffValidationError[];
   operationsApplied?: number;
   message?: string;
+  applied?: number[]; // Indices of successfully applied operations (when continueOnError is true)
+  failed?: number[]; // Indices of failed operations (when continueOnError is true)
+  staleConnectionsRemoved?: Array<{ from: string; to: string }>; // For cleanStaleConnections operation
 }
 
 // Helper type for node reference (supports both ID and name)
@@ -160,9 +186,9 @@ export function isNodeOperation(op: WorkflowDiffOperation): op is
   return ['addNode', 'removeNode', 'updateNode', 'moveNode', 'enableNode', 'disableNode'].includes(op.type);
 }
 
-export function isConnectionOperation(op: WorkflowDiffOperation): op is 
-  AddConnectionOperation | RemoveConnectionOperation | UpdateConnectionOperation {
-  return ['addConnection', 'removeConnection', 'updateConnection'].includes(op.type);
+export function isConnectionOperation(op: WorkflowDiffOperation): op is
+  AddConnectionOperation | RemoveConnectionOperation | UpdateConnectionOperation | CleanStaleConnectionsOperation | ReplaceConnectionsOperation {
+  return ['addConnection', 'removeConnection', 'updateConnection', 'cleanStaleConnections', 'replaceConnections'].includes(op.type);
 }
 
 export function isMetadataOperation(op: WorkflowDiffOperation): op is 

src/utils/template-sanitizer.ts

@@ -19,11 +19,17 @@ export const defaultSanitizerConfig: SanitizerConfig = {
   tokenPatterns: [
     /apify_api_[A-Za-z0-9]+/g,
     /sk-[A-Za-z0-9]+/g, // OpenAI tokens
+    /pat[A-Za-z0-9_]{40,}/g, // Airtable Personal Access Tokens
+    /ghp_[A-Za-z0-9]{36,}/g, // GitHub Personal Access Tokens
+    /gho_[A-Za-z0-9]{36,}/g, // GitHub OAuth tokens
     /Bearer\s+[A-Za-z0-9\-._~+\/]+=*/g // Generic bearer tokens
   ],
   replacements: new Map([
     ['apify_api_', 'apify_api_YOUR_TOKEN_HERE'],
     ['sk-', 'sk-YOUR_OPENAI_KEY_HERE'],
+    ['pat', 'patYOUR_AIRTABLE_TOKEN_HERE'],
+    ['ghp_', 'ghp_YOUR_GITHUB_TOKEN_HERE'],
+    ['gho_', 'gho_YOUR_GITHUB_TOKEN_HERE'],
     ['Bearer ', 'Bearer YOUR_TOKEN_HERE']
   ])
 };

tests/unit/mcp/handlers-workflow-diff.test.ts

@@ -130,6 +130,8 @@ describe('handlers-workflow-diff', () => {
         operationsApplied: 1,
         message: 'Successfully applied 1 operation',
         errors: [],
+        applied: [0],
+        failed: [],
       });
       mockApiClient.updateWorkflow.mockResolvedValue(updatedWorkflow);
 
@@ -143,6 +145,9 @@ describe('handlers-workflow-diff', () => {
           operationsApplied: 1,
           workflowId: 'test-workflow-id',
           workflowName: 'Test Workflow',
+          applied: [0],
+          failed: [],
+          errors: [],
         },
       });
 
@@ -226,6 +231,8 @@ describe('handlers-workflow-diff', () => {
         operationsApplied: 3,
         message: 'Successfully applied 3 operations',
         errors: [],
+        applied: [0, 1, 2],
+        failed: [],
       });
       mockApiClient.updateWorkflow.mockResolvedValue({ ...testWorkflow });
 
@@ -255,6 +262,8 @@ describe('handlers-workflow-diff', () => {
         operationsApplied: 0,
         message: 'Failed to apply operations',
         errors: ['Node "non-existent-node" not found'],
+        applied: [],
+        failed: [0],
       });
 
       const result = await handleUpdatePartialWorkflow(diffRequest);
@@ -265,6 +274,8 @@ describe('handlers-workflow-diff', () => {
         details: {
           errors: ['Node "non-existent-node" not found'],
           operationsApplied: 0,
+          applied: [],
+          failed: [0],
         },
       });
 

tests/unit/services/enhanced-config-validator-integration.test.ts

@@ -18,7 +18,9 @@ describe('EnhancedConfigValidator - Integration Tests', () => {
       getNode: vi.fn(),
       getNodeOperations: vi.fn().mockReturnValue([]),
       getNodeResources: vi.fn().mockReturnValue([]),
-      getOperationsForResource: vi.fn().mockReturnValue([])
+      getOperationsForResource: vi.fn().mockReturnValue([]),
+      getDefaultOperationForResource: vi.fn().mockReturnValue(undefined),
+      getNodePropertyDefaults: vi.fn().mockReturnValue({})
     };
 
     mockResourceService = {

tests/unit/services/enhanced-config-validator.test.ts

@@ -99,15 +99,15 @@ describe('EnhancedConfigValidator', () => {
       // Mock isPropertyVisible to return true
       vi.spyOn(EnhancedConfigValidator as any, 'isPropertyVisible').mockReturnValue(true);
 
-      const filtered = EnhancedConfigValidator['filterPropertiesByMode'](
+      const result = EnhancedConfigValidator['filterPropertiesByMode'](
         properties,
         { resource: 'message', operation: 'send' },
         'operation',
         { resource: 'message', operation: 'send' }
       );
 
-      expect(filtered).toHaveLength(1);
-      expect(filtered[0].name).toBe('channel');
+      expect(result.properties).toHaveLength(1);
+      expect(result.properties[0].name).toBe('channel');
     });
 
     it('should handle minimal validation mode', () => {
@@ -459,7 +459,7 @@ describe('EnhancedConfigValidator', () => {
       // Remove the mock to test real implementation
       vi.restoreAllMocks();
 
-      const filtered = EnhancedConfigValidator['filterPropertiesByMode'](
+      const result = EnhancedConfigValidator['filterPropertiesByMode'](
         properties,
         { resource: 'message', operation: 'send' },
         'operation',
@@ -467,9 +467,9 @@ describe('EnhancedConfigValidator', () => {
       );
 
       // Should include messageChannel and sharedProperty, but not userEmail
-      expect(filtered).toHaveLength(2);
-      expect(filtered.map(p => p.name)).toContain('messageChannel');
-      expect(filtered.map(p => p.name)).toContain('sharedProperty');
+      expect(result.properties).toHaveLength(2);
+      expect(result.properties.map(p => p.name)).toContain('messageChannel');
+      expect(result.properties.map(p => p.name)).toContain('sharedProperty');
     });
 
     it('should handle properties without displayOptions in operation mode', () => {
@@ -487,7 +487,7 @@ describe('EnhancedConfigValidator', () => {
 
       vi.restoreAllMocks();
 
-      const filtered = EnhancedConfigValidator['filterPropertiesByMode'](
+      const result = EnhancedConfigValidator['filterPropertiesByMode'](
         properties,
         { resource: 'user' },
         'operation',
@@ -495,9 +495,9 @@ describe('EnhancedConfigValidator', () => {
       );
 
       // Should include property without displayOptions
-      expect(filtered.map(p => p.name)).toContain('alwaysVisible');
+      expect(result.properties.map(p => p.name)).toContain('alwaysVisible');
       // Should not include conditionalProperty (wrong resource)
-      expect(filtered.map(p => p.name)).not.toContain('conditionalProperty');
+      expect(result.properties.map(p => p.name)).not.toContain('conditionalProperty');
     });
   });
 

tests/unit/services/execution-processor.test.ts

@@ -0,0 +1,665 @@
+/**
+ * Execution Processor Service Tests
+ *
+ * Comprehensive test coverage for execution filtering and processing
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  generatePreview,
+  filterExecutionData,
+  processExecution,
+} from '../../../src/services/execution-processor';
+import {
+  Execution,
+  ExecutionStatus,
+  ExecutionFilterOptions,
+} from '../../../src/types/n8n-api';
+
+/**
+ * Test data factories
+ */
+
+function createMockExecution(options: {
+  id?: string;
+  status?: ExecutionStatus;
+  nodeData?: Record<string, any>;
+  hasError?: boolean;
+}): Execution {
+  const { id = 'test-exec-1', status = ExecutionStatus.SUCCESS, nodeData = {}, hasError = false } = options;
+
+  return {
+    id,
+    workflowId: 'workflow-1',
+    status,
+    mode: 'manual',
+    finished: true,
+    startedAt: '2024-01-01T10:00:00.000Z',
+    stoppedAt: '2024-01-01T10:00:05.000Z',
+    data: {
+      resultData: {
+        runData: nodeData,
+        error: hasError ? { message: 'Test error' } : undefined,
+      },
+    },
+  };
+}
+
+function createNodeData(itemCount: number, includeError = false) {
+  const items = Array.from({ length: itemCount }, (_, i) => ({
+    json: {
+      id: i + 1,
+      name: `Item ${i + 1}`,
+      value: Math.random() * 100,
+      nested: {
+        field1: `value${i}`,
+        field2: true,
+      },
+    },
+  }));
+
+  return [
+    {
+      startTime: Date.now(),
+      executionTime: 123,
+      data: {
+        main: [items],
+      },
+      error: includeError ? { message: 'Node error' } : undefined,
+    },
+  ];
+}
+
+/**
+ * Preview Mode Tests
+ */
+describe('ExecutionProcessor - Preview Mode', () => {
+  it('should generate preview for empty execution', () => {
+    const execution = createMockExecution({ nodeData: {} });
+    const { preview, recommendation } = generatePreview(execution);
+
+    expect(preview.totalNodes).toBe(0);
+    expect(preview.executedNodes).toBe(0);
+    expect(preview.estimatedSizeKB).toBe(0);
+    expect(recommendation.canFetchFull).toBe(true);
+    expect(recommendation.suggestedMode).toBe('full'); // Empty execution is safe to fetch in full
+  });
+
+  it('should generate preview with accurate item counts', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+        'Filter': createNodeData(12),
+      },
+    });
+
+    const { preview } = generatePreview(execution);
+
+    expect(preview.totalNodes).toBe(2);
+    expect(preview.executedNodes).toBe(2);
+    expect(preview.nodes['HTTP Request'].itemCounts.output).toBe(50);
+    expect(preview.nodes['Filter'].itemCounts.output).toBe(12);
+  });
+
+  it('should extract data structure from nodes', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+    });
+
+    const { preview } = generatePreview(execution);
+    const structure = preview.nodes['HTTP Request'].dataStructure;
+
+    expect(structure).toHaveProperty('json');
+    expect(structure.json).toHaveProperty('id');
+    expect(structure.json).toHaveProperty('name');
+    expect(structure.json).toHaveProperty('nested');
+    expect(structure.json.id).toBe('number');
+    expect(structure.json.name).toBe('string');
+    expect(typeof structure.json.nested).toBe('object');
+  });
+
+  it('should estimate data size', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const { preview } = generatePreview(execution);
+
+    expect(preview.estimatedSizeKB).toBeGreaterThan(0);
+    expect(preview.nodes['HTTP Request'].estimatedSizeKB).toBeGreaterThan(0);
+  });
+
+  it('should detect error status in nodes', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5, true),
+      },
+    });
+
+    const { preview } = generatePreview(execution);
+
+    expect(preview.nodes['HTTP Request'].status).toBe('error');
+    expect(preview.nodes['HTTP Request'].error).toBeDefined();
+  });
+
+  it('should recommend full mode for small datasets', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+    });
+
+    const { recommendation } = generatePreview(execution);
+
+    expect(recommendation.canFetchFull).toBe(true);
+    expect(recommendation.suggestedMode).toBe('full');
+  });
+
+  it('should recommend filtered mode for large datasets', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(100),
+      },
+    });
+
+    const { recommendation } = generatePreview(execution);
+
+    expect(recommendation.canFetchFull).toBe(false);
+    expect(recommendation.suggestedMode).toBe('filtered');
+    expect(recommendation.suggestedItemsLimit).toBeGreaterThan(0);
+  });
+
+  it('should recommend summary mode for moderate datasets', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(30),
+      },
+    });
+
+    const { recommendation } = generatePreview(execution);
+
+    expect(recommendation.canFetchFull).toBe(false);
+    expect(recommendation.suggestedMode).toBe('summary');
+  });
+});
+
+/**
+ * Filtering Mode Tests
+ */
+describe('ExecutionProcessor - Filtering', () => {
+  it('should filter by node names', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(10),
+        'Filter': createNodeData(5),
+        'Set': createNodeData(3),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      nodeNames: ['HTTP Request', 'Filter'],
+    };
+
+    const result = filterExecutionData(execution, options);
+
+    expect(result.nodes).toHaveProperty('HTTP Request');
+    expect(result.nodes).toHaveProperty('Filter');
+    expect(result.nodes).not.toHaveProperty('Set');
+    expect(result.summary?.executedNodes).toBe(2);
+  });
+
+  it('should handle non-existent node names gracefully', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(10),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      nodeNames: ['NonExistent'],
+    };
+
+    const result = filterExecutionData(execution, options);
+
+    expect(Object.keys(result.nodes || {})).toHaveLength(0);
+    expect(result.summary?.executedNodes).toBe(0);
+  });
+
+  it('should limit items to 0 (structure only)', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      itemsLimit: 0,
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.metadata.itemsShown).toBe(0);
+    expect(nodeData?.data?.metadata.truncated).toBe(true);
+    expect(nodeData?.data?.metadata.totalItems).toBe(50);
+
+    // Check that we have structure but no actual values
+    const output = nodeData?.data?.output?.[0]?.[0];
+    expect(output).toBeDefined();
+    expect(typeof output).toBe('object');
+  });
+
+  it('should limit items to 2 (default)', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'summary',
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.metadata.itemsShown).toBe(2);
+    expect(nodeData?.data?.metadata.totalItems).toBe(50);
+    expect(nodeData?.data?.metadata.truncated).toBe(true);
+    expect(nodeData?.data?.output?.[0]).toHaveLength(2);
+  });
+
+  it('should limit items to custom value', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      itemsLimit: 5,
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.metadata.itemsShown).toBe(5);
+    expect(nodeData?.data?.metadata.truncated).toBe(true);
+    expect(nodeData?.data?.output?.[0]).toHaveLength(5);
+  });
+
+  it('should not truncate when itemsLimit is -1 (unlimited)', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      itemsLimit: -1,
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.metadata.itemsShown).toBe(50);
+    expect(nodeData?.data?.metadata.totalItems).toBe(50);
+    expect(nodeData?.data?.metadata.truncated).toBe(false);
+  });
+
+  it('should not truncate when items are less than limit', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(3),
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      itemsLimit: 5,
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.metadata.itemsShown).toBe(3);
+    expect(nodeData?.data?.metadata.truncated).toBe(false);
+  });
+
+  it('should include input data when requested', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': [
+          {
+            startTime: Date.now(),
+            executionTime: 100,
+            inputData: [[{ json: { input: 'test' } }]],
+            data: {
+              main: [[{ json: { output: 'result' } }]],
+            },
+          },
+        ],
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+      includeInputData: true,
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.input).toBeDefined();
+    expect(nodeData?.data?.input?.[0]?.[0]?.json?.input).toBe('test');
+  });
+
+  it('should not include input data by default', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': [
+          {
+            startTime: Date.now(),
+            executionTime: 100,
+            inputData: [[{ json: { input: 'test' } }]],
+            data: {
+              main: [[{ json: { output: 'result' } }]],
+            },
+          },
+        ],
+      },
+    });
+
+    const options: ExecutionFilterOptions = {
+      mode: 'filtered',
+    };
+
+    const result = filterExecutionData(execution, options);
+    const nodeData = result.nodes?.['HTTP Request'];
+
+    expect(nodeData?.data?.input).toBeUndefined();
+  });
+});
+
+/**
+ * Mode Tests
+ */
+describe('ExecutionProcessor - Modes', () => {
+  it('should handle preview mode', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'preview' });
+
+    expect(result.mode).toBe('preview');
+    expect(result.preview).toBeDefined();
+    expect(result.recommendation).toBeDefined();
+    expect(result.nodes).toBeUndefined();
+  });
+
+  it('should handle summary mode', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.mode).toBe('summary');
+    expect(result.summary).toBeDefined();
+    expect(result.nodes).toBeDefined();
+    expect(result.nodes?.['HTTP Request']?.data?.metadata.itemsShown).toBe(2);
+  });
+
+  it('should handle filtered mode', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const result = filterExecutionData(execution, {
+      mode: 'filtered',
+      itemsLimit: 5,
+    });
+
+    expect(result.mode).toBe('filtered');
+    expect(result.summary).toBeDefined();
+    expect(result.nodes?.['HTTP Request']?.data?.metadata.itemsShown).toBe(5);
+  });
+
+  it('should handle full mode', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'full' });
+
+    expect(result.mode).toBe('full');
+    expect(result.nodes?.['HTTP Request']?.data?.metadata.itemsShown).toBe(50);
+    expect(result.nodes?.['HTTP Request']?.data?.metadata.truncated).toBe(false);
+  });
+});
+
+/**
+ * Edge Cases
+ */
+describe('ExecutionProcessor - Edge Cases', () => {
+  it('should handle execution with no data', () => {
+    const execution: Execution = {
+      id: 'test-1',
+      workflowId: 'workflow-1',
+      status: ExecutionStatus.SUCCESS,
+      mode: 'manual',
+      finished: true,
+      startedAt: '2024-01-01T10:00:00.000Z',
+      stoppedAt: '2024-01-01T10:00:05.000Z',
+    };
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.summary?.totalNodes).toBe(0);
+    expect(result.summary?.executedNodes).toBe(0);
+  });
+
+  it('should handle execution with error', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+      hasError: true,
+    });
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.error).toBeDefined();
+  });
+
+  it('should handle empty node data arrays', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': [],
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.nodes?.['HTTP Request']).toBeDefined();
+    expect(result.nodes?.['HTTP Request'].itemsOutput).toBe(0);
+  });
+
+  it('should handle nested data structures', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': [
+          {
+            startTime: Date.now(),
+            executionTime: 100,
+            data: {
+              main: [[{
+                json: {
+                  deeply: {
+                    nested: {
+                      structure: {
+                        value: 'test',
+                        array: [1, 2, 3],
+                      },
+                    },
+                  },
+                },
+              }]],
+            },
+          },
+        ],
+      },
+    });
+
+    const { preview } = generatePreview(execution);
+    const structure = preview.nodes['HTTP Request'].dataStructure;
+
+    expect(structure.json.deeply).toBeDefined();
+    expect(typeof structure.json.deeply).toBe('object');
+  });
+
+  it('should calculate duration correctly', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.duration).toBe(5000); // 5 seconds
+  });
+
+  it('should handle execution without stop time', () => {
+    const execution: Execution = {
+      id: 'test-1',
+      workflowId: 'workflow-1',
+      status: ExecutionStatus.WAITING,
+      mode: 'manual',
+      finished: false,
+      startedAt: '2024-01-01T10:00:00.000Z',
+      data: {
+        resultData: {
+          runData: {},
+        },
+      },
+    };
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.duration).toBeUndefined();
+    expect(result.finished).toBe(false);
+  });
+});
+
+/**
+ * processExecution Tests
+ */
+describe('ExecutionProcessor - processExecution', () => {
+  it('should return original execution when no options provided', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+    });
+
+    const result = processExecution(execution, {});
+
+    expect(result).toBe(execution);
+  });
+
+  it('should process when mode is specified', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+      },
+    });
+
+    const result = processExecution(execution, { mode: 'preview' });
+
+    expect(result).not.toBe(execution);
+    expect((result as any).mode).toBe('preview');
+  });
+
+  it('should process when filtering options are provided', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(5),
+        'Filter': createNodeData(3),
+      },
+    });
+
+    const result = processExecution(execution, { nodeNames: ['HTTP Request'] });
+
+    expect(result).not.toBe(execution);
+    expect((result as any).nodes).toHaveProperty('HTTP Request');
+    expect((result as any).nodes).not.toHaveProperty('Filter');
+  });
+});
+
+/**
+ * Summary Statistics Tests
+ */
+describe('ExecutionProcessor - Summary Statistics', () => {
+  it('should calculate hasMoreData correctly', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(50),
+      },
+    });
+
+    const result = filterExecutionData(execution, {
+      mode: 'summary',
+      itemsLimit: 2,
+    });
+
+    expect(result.summary?.hasMoreData).toBe(true);
+  });
+
+  it('should set hasMoreData to false when all data is included', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(2),
+      },
+    });
+
+    const result = filterExecutionData(execution, {
+      mode: 'summary',
+      itemsLimit: 5,
+    });
+
+    expect(result.summary?.hasMoreData).toBe(false);
+  });
+
+  it('should count total items correctly across multiple nodes', () => {
+    const execution = createMockExecution({
+      nodeData: {
+        'HTTP Request': createNodeData(10),
+        'Filter': createNodeData(5),
+        'Set': createNodeData(3),
+      },
+    });
+
+    const result = filterExecutionData(execution, { mode: 'summary' });
+
+    expect(result.summary?.totalItems).toBe(18);
+  });
+});

tests/unit/services/validation-fixes.test.ts

@@ -0,0 +1,377 @@
+/**
+ * Test cases for validation fixes - specifically for false positives
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { WorkflowValidator } from '../../../src/services/workflow-validator';
+import { EnhancedConfigValidator } from '../../../src/services/enhanced-config-validator';
+import { NodeRepository } from '../../../src/database/node-repository';
+import { DatabaseAdapter, PreparedStatement, RunResult } from '../../../src/database/database-adapter';
+
+// Mock logger to prevent console output
+vi.mock('@/utils/logger', () => ({
+  Logger: vi.fn().mockImplementation(() => ({
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn()
+  }))
+}));
+
+// Create a complete mock for DatabaseAdapter
+class MockDatabaseAdapter implements DatabaseAdapter {
+  private statements = new Map<string, MockPreparedStatement>();
+  private mockData = new Map<string, any>();
+
+  prepare = vi.fn((sql: string) => {
+    if (!this.statements.has(sql)) {
+      this.statements.set(sql, new MockPreparedStatement(sql, this.mockData));
+    }
+    return this.statements.get(sql)!;
+  });
+
+  exec = vi.fn();
+  close = vi.fn();
+  pragma = vi.fn();
+  transaction = vi.fn((fn: () => any) => fn());
+  checkFTS5Support = vi.fn(() => true);
+  inTransaction = false;
+
+  // Test helper to set mock data
+  _setMockData(key: string, value: any) {
+    this.mockData.set(key, value);
+  }
+
+  // Test helper to get statement by SQL
+  _getStatement(sql: string) {
+    return this.statements.get(sql);
+  }
+}
+
+class MockPreparedStatement implements PreparedStatement {
+  run = vi.fn((...params: any[]): RunResult => ({ changes: 1, lastInsertRowid: 1 }));
+  get = vi.fn();
+  all = vi.fn(() => []);
+  iterate = vi.fn();
+  pluck = vi.fn(() => this);
+  expand = vi.fn(() => this);
+  raw = vi.fn(() => this);
+  columns = vi.fn(() => []);
+  bind = vi.fn(() => this);
+
+  constructor(private sql: string, private mockData: Map<string, any>) {
+    // Configure get() based on SQL pattern
+    if (sql.includes('SELECT * FROM nodes WHERE node_type = ?')) {
+      this.get = vi.fn((nodeType: string) => this.mockData.get(`node:${nodeType}`));
+    }
+  }
+}
+
+describe('Validation Fixes for False Positives', () => {
+  let repository: any;
+  let mockAdapter: MockDatabaseAdapter;
+  let validator: WorkflowValidator;
+
+  beforeEach(() => {
+    mockAdapter = new MockDatabaseAdapter();
+    repository = new NodeRepository(mockAdapter);
+
+    // Add findSimilarNodes method for WorkflowValidator
+    repository.findSimilarNodes = vi.fn().mockReturnValue([]);
+
+    // Initialize services
+    EnhancedConfigValidator.initializeSimilarityServices(repository);
+
+    validator = new WorkflowValidator(repository, EnhancedConfigValidator);
+
+    // Mock Google Drive node data
+    const googleDriveNodeData = {
+      node_type: 'nodes-base.googleDrive',
+      package_name: 'n8n-nodes-base',
+      display_name: 'Google Drive',
+      description: 'Access Google Drive',
+      category: 'input',
+      development_style: 'programmatic',
+      is_ai_tool: 0,
+      is_trigger: 0,
+      is_webhook: 0,
+      is_versioned: 1,
+      version: '3',
+      properties_schema: JSON.stringify([
+        {
+          name: 'resource',
+          type: 'options',
+          default: 'file',
+          options: [
+            { value: 'file', name: 'File' },
+            { value: 'fileFolder', name: 'File/Folder' },
+            { value: 'folder', name: 'Folder' },
+            { value: 'drive', name: 'Shared Drive' }
+          ]
+        },
+        {
+          name: 'operation',
+          type: 'options',
+          displayOptions: {
+            show: {
+              resource: ['fileFolder']
+            }
+          },
+          default: 'search',
+          options: [
+            { value: 'search', name: 'Search' }
+          ]
+        },
+        {
+          name: 'queryString',
+          type: 'string',
+          displayOptions: {
+            show: {
+              resource: ['fileFolder'],
+              operation: ['search']
+            }
+          }
+        },
+        {
+          name: 'filter',
+          type: 'collection',
+          displayOptions: {
+            show: {
+              resource: ['fileFolder'],
+              operation: ['search']
+            }
+          },
+          default: {},
+          options: [
+            {
+              name: 'folderId',
+              type: 'resourceLocator',
+              default: { mode: 'list', value: '' }
+            }
+          ]
+        },
+        {
+          name: 'options',
+          type: 'collection',
+          displayOptions: {
+            show: {
+              resource: ['fileFolder'],
+              operation: ['search']
+            }
+          },
+          default: {},
+          options: [
+            {
+              name: 'fields',
+              type: 'multiOptions',
+              default: []
+            }
+          ]
+        }
+      ]),
+      operations: JSON.stringify([]),
+      credentials_required: JSON.stringify([]),
+      documentation: null,
+      outputs: null,
+      output_names: null
+    };
+
+    // Set mock data for node retrieval
+    mockAdapter._setMockData('node:nodes-base.googleDrive', googleDriveNodeData);
+    mockAdapter._setMockData('node:n8n-nodes-base.googleDrive', googleDriveNodeData);
+  });
+
+  describe('Google Drive fileFolder Resource Validation', () => {
+    it('should validate fileFolder as a valid resource', () => {
+      const config = {
+        resource: 'fileFolder'
+      };
+
+      const node = repository.getNode('nodes-base.googleDrive');
+      const result = EnhancedConfigValidator.validateWithMode(
+        'nodes-base.googleDrive',
+        config,
+        node.properties,
+        'operation',
+        'ai-friendly'
+      );
+
+      expect(result.valid).toBe(true);
+
+      // Should not have resource error
+      const resourceError = result.errors.find(e => e.property === 'resource');
+      expect(resourceError).toBeUndefined();
+    });
+
+    it('should apply default operation when not specified', () => {
+      const config = {
+        resource: 'fileFolder'
+        // operation is not specified, should use default 'search'
+      };
+
+      const node = repository.getNode('nodes-base.googleDrive');
+      const result = EnhancedConfigValidator.validateWithMode(
+        'nodes-base.googleDrive',
+        config,
+        node.properties,
+        'operation',
+        'ai-friendly'
+      );
+
+      expect(result.valid).toBe(true);
+
+      // Should not have operation error
+      const operationError = result.errors.find(e => e.property === 'operation');
+      expect(operationError).toBeUndefined();
+    });
+
+    it('should not warn about properties being unused when default operation is applied', () => {
+      const config = {
+        resource: 'fileFolder',
+        // operation not specified, will use default 'search'
+        queryString: '=',
+        filter: {
+          folderId: {
+            __rl: true,
+            value: '={{ $json.id }}',
+            mode: 'id'
+          }
+        },
+        options: {
+          fields: ['id', 'kind', 'mimeType', 'name', 'webViewLink']
+        }
+      };
+
+      const node = repository.getNode('nodes-base.googleDrive');
+      const result = EnhancedConfigValidator.validateWithMode(
+        'nodes-base.googleDrive',
+        config,
+        node.properties,
+        'operation',
+        'ai-friendly'
+      );
+
+      // Should be valid
+      expect(result.valid).toBe(true);
+
+      // Should not have warnings about properties not being used
+      const propertyWarnings = result.warnings.filter(w =>
+        w.message.includes("won't be used") || w.message.includes("not used")
+      );
+      expect(propertyWarnings.length).toBe(0);
+    });
+
+    it.skip('should validate complete workflow with Google Drive nodes', async () => {
+      const workflow = {
+        name: 'Test Google Drive Workflow',
+        nodes: [
+          {
+            id: '1',
+            name: 'Google Drive',
+            type: 'n8n-nodes-base.googleDrive',
+            typeVersion: 3,
+            position: [100, 100] as [number, number],
+            parameters: {
+              resource: 'fileFolder',
+              queryString: '=',
+              filter: {
+                folderId: {
+                  __rl: true,
+                  value: '={{ $json.id }}',
+                  mode: 'id'
+                }
+              },
+              options: {
+                fields: ['id', 'kind', 'mimeType', 'name', 'webViewLink']
+              }
+            }
+          }
+        ],
+        connections: {}
+      };
+
+      let result;
+      try {
+        result = await validator.validateWorkflow(workflow, {
+          validateNodes: true,
+          validateConnections: true,
+          validateExpressions: true,
+          profile: 'ai-friendly'
+        });
+      } catch (error) {
+        console.log('Validation threw error:', error);
+        throw error;
+      }
+
+      // Debug output
+      if (!result.valid) {
+        console.log('Validation errors:', JSON.stringify(result.errors, null, 2));
+        console.log('Validation warnings:', JSON.stringify(result.warnings, null, 2));
+      }
+
+      // Should be valid
+      expect(result.valid).toBe(true);
+
+      // Should not have "Invalid resource" errors
+      const resourceErrors = result.errors.filter((e: any) =>
+        e.message.includes('Invalid resource') && e.message.includes('fileFolder')
+      );
+      expect(resourceErrors.length).toBe(0);
+    });
+
+    it('should still report errors for truly invalid resources', () => {
+      const config = {
+        resource: 'invalidResource'
+      };
+
+      const node = repository.getNode('nodes-base.googleDrive');
+      const result = EnhancedConfigValidator.validateWithMode(
+        'nodes-base.googleDrive',
+        config,
+        node.properties,
+        'operation',
+        'ai-friendly'
+      );
+
+      expect(result.valid).toBe(false);
+
+      // Should have resource error for invalid resource
+      const resourceError = result.errors.find(e => e.property === 'resource');
+      expect(resourceError).toBeDefined();
+      expect(resourceError!.message).toContain('Invalid resource "invalidResource"');
+    });
+  });
+
+  describe('Node Type Validation', () => {
+    it('should accept both n8n-nodes-base and nodes-base prefixes', async () => {
+      const workflow1 = {
+        name: 'Test with n8n-nodes-base prefix',
+        nodes: [
+          {
+            id: '1',
+            name: 'Google Drive',
+            type: 'n8n-nodes-base.googleDrive',
+            typeVersion: 3,
+            position: [100, 100] as [number, number],
+            parameters: {
+              resource: 'file'
+            }
+          }
+        ],
+        connections: {}
+      };
+
+      const result1 = await validator.validateWorkflow(workflow1);
+
+      // Should not have errors about node type format
+      const typeErrors1 = result1.errors.filter((e: any) =>
+        e.message.includes('Invalid node type') ||
+        e.message.includes('must use the full package name')
+      );
+      expect(typeErrors1.length).toBe(0);
+
+      // Note: nodes-base prefix might still be invalid in actual workflows
+      // but the validator shouldn't incorrectly suggest it's always wrong
+    });
+  });
+});

tests/unit/services/workflow-validator-comprehensive.test.ts

@@ -507,13 +507,14 @@ describe('WorkflowValidator - Comprehensive Tests', () => {
       expect(mockNodeRepository.getNode).not.toHaveBeenCalled();
     });
 
-    it('should error for invalid node type starting with nodes-base', async () => {
+    it('should accept both nodes-base and n8n-nodes-base prefixes as valid', async () => {
+      // This test verifies the fix for false positives - both prefixes are valid
       const workflow = {
         nodes: [
           {
             id: '1',
             name: 'Webhook',
-            type: 'nodes-base.webhook', // Missing n8n- prefix
+            type: 'nodes-base.webhook', // This is now valid (normalized internally)
             position: [100, 100],
             parameters: {}
           }
@@ -521,11 +522,24 @@ describe('WorkflowValidator - Comprehensive Tests', () => {
         connections: {}
       } as any;
 
+      // Mock the normalized node lookup
+      (mockNodeRepository.getNode as any) = vi.fn((type: string) => {
+        if (type === 'nodes-base.webhook') {
+          return {
+            nodeType: 'nodes-base.webhook',
+            displayName: 'Webhook',
+            properties: [],
+            isVersioned: false
+          };
+        }
+        return null;
+      });
+
       const result = await validator.validateWorkflow(workflow as any);
 
-      expect(result.valid).toBe(false);
-      expect(result.errors.some(e => e.message.includes('Invalid node type: "nodes-base.webhook"'))).toBe(true);
-      expect(result.errors.some(e => e.message.includes('Use "n8n-nodes-base.webhook" instead'))).toBe(true);
+      // Should NOT error for nodes-base prefix - it's valid!
+      expect(result.valid).toBe(true);
+      expect(result.errors.some(e => e.message.includes('Invalid node type'))).toBe(false);
     });
 
     it.skip('should handle unknown node types with suggestions', async () => {
@@ -1826,11 +1840,11 @@ describe('WorkflowValidator - Comprehensive Tests', () => {
             parameters: {},
             typeVersion: 2
           },
-          // Node with wrong type format
+          // Node with valid alternative prefix (no longer an error)
           {
             id: '2',
             name: 'HTTP1',
-            type: 'nodes-base.httpRequest', // Wrong prefix
+            type: 'nodes-base.httpRequest', // Valid prefix (normalized internally)
             position: [300, 100],
             parameters: {}
           },
@@ -1900,12 +1914,11 @@ describe('WorkflowValidator - Comprehensive Tests', () => {
 
       const result = await validator.validateWorkflow(workflow as any);
 
-      // Should have multiple errors
+      // Should have multiple errors (but not for the nodes-base prefix)
       expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(3);
+      expect(result.errors.length).toBeGreaterThan(2); // Reduced by 1 since nodes-base prefix is now valid
 
-      // Specific errors
-      expect(result.errors.some(e => e.message.includes('Invalid node type: "nodes-base.httpRequest"'))).toBe(true);
+      // Specific errors (removed the invalid node type error as it's no longer invalid)
       expect(result.errors.some(e => e.message.includes('Missing required property \'typeVersion\''))).toBe(true);
       expect(result.errors.some(e => e.message.includes('Node-level properties onError are in the wrong location'))).toBe(true);
       expect(result.errors.some(e => e.message.includes('Connection uses node ID \'5\' instead of node name'))).toBe(true);

tests/unit/services/workflow-validator-with-mocks.test.ts

@@ -448,9 +448,32 @@ describe('WorkflowValidator - Simple Unit Tests', () => {
       expect(result.warnings.some(w => w.message.includes('Outdated typeVersion'))).toBe(true);
     });
 
-    it('should detect invalid node type format', async () => {
-      // Arrange
-      const mockRepository = createMockRepository({});
+    it('should normalize and validate nodes-base prefix to find the node', async () => {
+      // Arrange - Test that nodes-base prefix is normalized to find the node
+      // The repository only has the node under the normalized key
+      const nodeData = {
+        'nodes-base.webhook': {  // Repository has it under normalized form
+          type: 'nodes-base.webhook',
+          displayName: 'Webhook',
+          isVersioned: true,
+          version: 2,
+          properties: []
+        }
+      };
+
+      // Mock repository that simulates the normalization behavior
+      const mockRepository = {
+        getNode: vi.fn((type: string) => {
+          // First call with original type returns null
+          // Second call with normalized type returns the node
+          if (type === 'nodes-base.webhook') {
+            return nodeData['nodes-base.webhook'];
+          }
+          return null;
+        }),
+        findSimilarNodes: vi.fn().mockReturnValue([])
+      };
+
       const mockValidatorClass = createMockValidatorClass({
         valid: true,
         errors: [],
@@ -461,14 +484,15 @@ describe('WorkflowValidator - Simple Unit Tests', () => {
       validator = new WorkflowValidator(mockRepository as any, mockValidatorClass as any);
 
       const workflow = {
-        name: 'Invalid Type Format',
+        name: 'Valid Alternative Prefix',
         nodes: [
           {
             id: '1',
             name: 'Webhook',
-            type: 'nodes-base.webhook', // Invalid format
+            type: 'nodes-base.webhook', // Using the alternative prefix
             position: [250, 300] as [number, number],
-            parameters: {}
+            parameters: {},
+            typeVersion: 2
           }
         ],
         connections: {}
@@ -477,12 +501,12 @@ describe('WorkflowValidator - Simple Unit Tests', () => {
       // Act
       const result = await validator.validateWorkflow(workflow as any);
 
-      // Assert
-      expect(result.valid).toBe(false);
-      expect(result.errors.some(e => 
-        e.message.includes('Invalid node type') && 
-        e.message.includes('Use "n8n-nodes-base.webhook" instead')
-      )).toBe(true);
+      // Assert - The node should be found through normalization
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+
+      // Verify the repository was called (once with original, once with normalized)
+      expect(mockRepository.getNode).toHaveBeenCalled();
     });
   });
 });

tests/unit/templates/batch-processor.test.ts

@@ -71,7 +71,7 @@ describe('BatchProcessor', () => {
     
     options = {
       apiKey: 'test-api-key',
-      model: 'gpt-4o-mini',
+      model: 'gpt-5-mini-2025-08-07',
       batchSize: 3,
       outputDir: './test-temp'
     };
@@ -177,13 +177,38 @@ describe('BatchProcessor', () => {
 
     it('should handle batch submission errors gracefully', async () => {
       mockClient.files.create.mockRejectedValue(new Error('Upload failed'));
-      
+
       const results = await processor.processTemplates([mockTemplates[0]]);
-      
+
       // Should not throw, should return empty results
       expect(results.size).toBe(0);
     });
 
+    it('should log submission errors to console and logger', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error');
+      const { logger } = await import('../../../src/utils/logger');
+      const loggerErrorSpy = vi.spyOn(logger, 'error');
+
+      mockClient.files.create.mockRejectedValue(new Error('Network error'));
+
+      await processor.processTemplates([mockTemplates[0]]);
+
+      // Should log error to console (actual format from line 95: "   ❌ Batch N failed:", error)
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Batch'),
+        expect.objectContaining({ message: 'Network error' })
+      );
+
+      // Should also log to logger (line 94)
+      expect(loggerErrorSpy).toHaveBeenCalledWith(
+        expect.stringMatching(/Error processing batch/),
+        expect.objectContaining({ message: 'Network error' })
+      );
+
+      consoleErrorSpy.mockRestore();
+      loggerErrorSpy.mockRestore();
+    });
+
     // Skipping: Parallel batch processing creates unhandled promise rejections in tests
     // The error handling works in production but the parallel promise structure is
     // difficult to test cleanly without refactoring the implementation
@@ -368,7 +393,7 @@ describe('BatchProcessor', () => {
     it('should download and parse results correctly', async () => {
       const batchJob = { output_file_id: 'output-123' };
       const fileContent = '{"custom_id": "template-1"}\n{"custom_id": "template-2"}';
-      
+
       mockClient.files.content.mockResolvedValue({
         text: () => Promise.resolve(fileContent)
       });
@@ -377,7 +402,7 @@ describe('BatchProcessor', () => {
         { templateId: 1, metadata: { categories: ['test'] } },
         { templateId: 2, metadata: { categories: ['test2'] } }
       ];
-      
+
       mockGenerator.parseResult.mockReturnValueOnce(mockResults[0])
                                 .mockReturnValueOnce(mockResults[1]);
 
@@ -389,17 +414,17 @@ describe('BatchProcessor', () => {
     });
 
     it('should throw error when no output file available', async () => {
-      const batchJob = { output_file_id: null };
+      const batchJob = { output_file_id: null, error_file_id: null };
 
       await expect(
         (processor as any).retrieveResults(batchJob)
-      ).rejects.toThrow('No output file available for batch job');
+      ).rejects.toThrow('No output file or error file available for batch job');
     });
 
     it('should handle malformed result lines gracefully', async () => {
       const batchJob = { output_file_id: 'output-123' };
       const fileContent = '{"valid": "json"}\ninvalid json line\n{"another": "valid"}';
-      
+
       mockClient.files.content.mockResolvedValue({
         text: () => Promise.resolve(fileContent)
       });
@@ -422,6 +447,227 @@ describe('BatchProcessor', () => {
         (processor as any).retrieveResults(batchJob)
       ).rejects.toThrow('Download failed');
     });
+
+    it('should process error file when present', async () => {
+      const batchJob = {
+        id: 'batch-123',
+        output_file_id: 'output-123',
+        error_file_id: 'error-456'
+      };
+
+      const outputContent = '{"custom_id": "template-1"}';
+      const errorContent = '{"custom_id": "template-2", "error": {"message": "Rate limit exceeded"}}\n{"custom_id": "template-3", "response": {"body": {"error": {"message": "Invalid request"}}}}';
+
+      mockClient.files.content
+        .mockResolvedValueOnce({ text: () => Promise.resolve(outputContent) })
+        .mockResolvedValueOnce({ text: () => Promise.resolve(errorContent) });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const successResult = { templateId: 1, metadata: { categories: ['success'] } };
+      mockGenerator.parseResult.mockReturnValue(successResult);
+
+      // Mock getDefaultMetadata
+      const defaultMetadata = {
+        categories: ['General'],
+        complexity: 'medium',
+        estimatedSetupMinutes: 15,
+        useCases: [],
+        requiredServices: [],
+        targetAudience: []
+      };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      // Should have 1 successful + 2 failed results
+      expect(results).toHaveLength(3);
+      expect(mockClient.files.content).toHaveBeenCalledWith('output-123');
+      expect(mockClient.files.content).toHaveBeenCalledWith('error-456');
+      expect(mockedFs.writeFileSync).toHaveBeenCalled();
+
+      // Check error file was saved
+      const savedPath = (mockedFs.writeFileSync as any).mock.calls[0][0];
+      expect(savedPath).toContain('batch_batch-123_error.jsonl');
+    });
+
+    it('should handle error file with empty lines', async () => {
+      const batchJob = {
+        id: 'batch-789',
+        error_file_id: 'error-789'
+      };
+
+      const errorContent = '\n{"custom_id": "template-1", "error": {"message": "Failed"}}\n\n{"custom_id": "template-2", "error": {"message": "Error"}}\n';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = {
+        categories: ['General'],
+        complexity: 'medium',
+        estimatedSetupMinutes: 15,
+        useCases: [],
+        requiredServices: [],
+        targetAudience: []
+      };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      // Should skip empty lines and process only valid ones
+      expect(results).toHaveLength(2);
+      expect(results[0].templateId).toBe(1);
+      expect(results[0].error).toBe('Failed');
+      expect(results[1].templateId).toBe(2);
+      expect(results[1].error).toBe('Error');
+    });
+
+    it('should assign default metadata to failed templates', async () => {
+      const batchJob = {
+        error_file_id: 'error-456'
+      };
+
+      const errorContent = '{"custom_id": "template-42", "error": {"message": "Timeout"}}';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = {
+        categories: ['General'],
+        complexity: 'medium',
+        estimatedSetupMinutes: 15,
+        useCases: ['General automation'],
+        requiredServices: [],
+        targetAudience: ['Developers']
+      };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].templateId).toBe(42);
+      expect(results[0].metadata).toEqual(defaultMetadata);
+      expect(results[0].error).toBe('Timeout');
+    });
+
+    it('should handle malformed error lines gracefully', async () => {
+      const batchJob = {
+        error_file_id: 'error-999'
+      };
+
+      const errorContent = '{"custom_id": "template-1", "error": {"message": "Valid error"}}\ninvalid json\n{"invalid": "no custom_id"}\n{"custom_id": "template-2", "error": {"message": "Another valid"}}';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = { categories: ['General'] };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      // Should only process valid error lines with template IDs
+      expect(results).toHaveLength(2);
+      expect(results[0].templateId).toBe(1);
+      expect(results[1].templateId).toBe(2);
+    });
+
+    it('should extract error message from response body', async () => {
+      const batchJob = {
+        error_file_id: 'error-123'
+      };
+
+      const errorContent = '{"custom_id": "template-5", "response": {"body": {"error": {"message": "API error from response body"}}}}';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = { categories: ['General'] };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].error).toBe('API error from response body');
+    });
+
+    it('should use unknown error when no error message found', async () => {
+      const batchJob = {
+        error_file_id: 'error-000'
+      };
+
+      const errorContent = '{"custom_id": "template-10"}';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = { categories: ['General'] };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      expect(results).toHaveLength(1);
+      expect(results[0].error).toBe('Unknown error');
+    });
+
+    it('should handle error file download failure gracefully', async () => {
+      const batchJob = {
+        output_file_id: 'output-123',
+        error_file_id: 'error-failed'
+      };
+
+      const outputContent = '{"custom_id": "template-1"}';
+
+      mockClient.files.content
+        .mockResolvedValueOnce({ text: () => Promise.resolve(outputContent) })
+        .mockRejectedValueOnce(new Error('Error file download failed'));
+
+      const successResult = { templateId: 1, metadata: { categories: ['success'] } };
+      mockGenerator.parseResult.mockReturnValue(successResult);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      // Should still return successful results even if error file fails
+      expect(results).toHaveLength(1);
+      expect(results[0].templateId).toBe(1);
+    });
+
+    it('should skip templates with invalid or zero ID in error file', async () => {
+      const batchJob = {
+        error_file_id: 'error-invalid'
+      };
+
+      const errorContent = '{"custom_id": "template-0", "error": {"message": "Zero ID"}}\n{"custom_id": "invalid-id", "error": {"message": "Invalid"}}\n{"custom_id": "template-5", "error": {"message": "Valid ID"}}';
+
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(errorContent)
+      });
+
+      mockedFs.writeFileSync = vi.fn();
+
+      const defaultMetadata = { categories: ['General'] };
+      (processor as any).generator.getDefaultMetadata = vi.fn().mockReturnValue(defaultMetadata);
+
+      const results = await (processor as any).retrieveResults(batchJob);
+
+      // Should only include template with valid ID > 0
+      expect(results).toHaveLength(1);
+      expect(results[0].templateId).toBe(5);
+    });
   });
 
   describe('cleanup', () => {
@@ -526,7 +772,7 @@ describe('BatchProcessor', () => {
       mockClient.files.create.mockRejectedValue(new Error('Upload failed'));
 
       const submitBatch = (processor as any).submitBatch.bind(processor);
-      
+
       await expect(
         submitBatch(templates, 'error_test')
       ).rejects.toThrow('Upload failed');
@@ -544,7 +790,7 @@ describe('BatchProcessor', () => {
 
       // Mock successful processing
       mockClient.files.create.mockResolvedValue({ id: 'file-123' });
-      const completedJob = { 
+      const completedJob = {
         id: 'batch-123',
         status: 'completed',
         output_file_id: 'output-123'
@@ -565,4 +811,391 @@ describe('BatchProcessor', () => {
       expect(mockClient.batches.create).toHaveBeenCalled();
     });
   });
+
+  describe('submitBatch', () => {
+    it('should clean up input file immediately after upload', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      const promise = (processor as any).submitBatch(templates, 'test_batch');
+
+      // Wait a bit for synchronous cleanup
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      // Input file should be deleted immediately
+      expect(mockedFs.unlinkSync).toHaveBeenCalled();
+
+      await promise;
+    });
+
+    it('should clean up OpenAI files after batch completion', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-upload-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      await (processor as any).submitBatch(templates, 'cleanup_test');
+
+      // Wait for promise chain to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Should have attempted to delete the input file
+      expect(mockClient.files.del).toHaveBeenCalledWith('file-upload-123');
+    });
+
+    it('should handle cleanup errors gracefully', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      mockClient.files.del.mockRejectedValue(new Error('Delete failed'));
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      // Should not throw even if cleanup fails
+      await expect(
+        (processor as any).submitBatch(templates, 'error_cleanup')
+      ).resolves.toBeDefined();
+    });
+
+    it('should handle local file cleanup errors silently', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockedFs.unlinkSync = vi.fn().mockImplementation(() => {
+        throw new Error('Cannot delete file');
+      });
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      // Should not throw even if local cleanup fails
+      await expect(
+        (processor as any).submitBatch(templates, 'local_cleanup_error')
+      ).resolves.toBeDefined();
+    });
+  });
+
+  describe('progress callback', () => {
+    it('should call progress callback during batch submission', async () => {
+      const templates = [
+        { templateId: 1, name: 'T1', nodes: ['node1'] },
+        { templateId: 2, name: 'T2', nodes: ['node2'] },
+        { templateId: 3, name: 'T3', nodes: ['node3'] },
+        { templateId: 4, name: 'T4', nodes: ['node4'] }
+      ];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve('{"custom_id": "template-1"}')
+      });
+      mockGenerator.parseResult.mockReturnValue({
+        templateId: 1,
+        metadata: { categories: ['test'] }
+      });
+
+      const progressCallback = vi.fn();
+
+      await processor.processTemplates(templates, progressCallback);
+
+      // Should be called during submission and retrieval
+      expect(progressCallback).toHaveBeenCalled();
+      expect(progressCallback.mock.calls.some((call: any) =>
+        call[0].includes('Submitting')
+      )).toBe(true);
+    });
+
+    it('should work without progress callback', async () => {
+      const templates = [{ templateId: 1, name: 'T1', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve('{"custom_id": "template-1"}')
+      });
+      mockGenerator.parseResult.mockReturnValue({
+        templateId: 1,
+        metadata: { categories: ['test'] }
+      });
+
+      // Should not throw without callback
+      await expect(
+        processor.processTemplates(templates)
+      ).resolves.toBeDefined();
+    });
+
+    it('should call progress callback with correct parameters', async () => {
+      const templates = [
+        { templateId: 1, name: 'T1', nodes: ['node1'] },
+        { templateId: 2, name: 'T2', nodes: ['node2'] }
+      ];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve('{"custom_id": "template-1"}')
+      });
+      mockGenerator.parseResult.mockReturnValue({
+        templateId: 1,
+        metadata: { categories: ['test'] }
+      });
+
+      const progressCallback = vi.fn();
+
+      await processor.processTemplates(templates, progressCallback);
+
+      // Check that callback was called with proper arguments
+      const submissionCall = progressCallback.mock.calls.find((call: any) =>
+        call[0].includes('Submitting')
+      );
+      expect(submissionCall).toBeDefined();
+      if (submissionCall) {
+        expect(submissionCall[1]).toBeGreaterThanOrEqual(0);
+        expect(submissionCall[2]).toBe(2);
+      }
+    });
+  });
+
+  describe('batch result merging', () => {
+    it('should merge results from multiple batches', async () => {
+      const templates = Array.from({ length: 6 }, (_, i) => ({
+        templateId: i + 1,
+        name: `T${i + 1}`,
+        nodes: ['node']
+      }));
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+
+      // Create different completed jobs for each batch
+      let batchCounter = 0;
+      mockClient.batches.create.mockImplementation(() => {
+        batchCounter++;
+        return Promise.resolve({
+          id: `batch-${batchCounter}`,
+          status: 'completed',
+          output_file_id: `output-${batchCounter}`
+        });
+      });
+
+      mockClient.batches.retrieve.mockImplementation((id: string) => {
+        return Promise.resolve({
+          id,
+          status: 'completed',
+          output_file_id: `output-${id.split('-')[1]}`
+        });
+      });
+
+      let fileCounter = 0;
+      mockClient.files.content.mockImplementation(() => {
+        fileCounter++;
+        return Promise.resolve({
+          text: () => Promise.resolve(`{"custom_id": "template-${fileCounter}"}`)
+        });
+      });
+
+      mockGenerator.parseResult.mockImplementation((result: any) => {
+        const id = parseInt(result.custom_id.split('-')[1]);
+        return {
+          templateId: id,
+          metadata: { categories: [`batch-${Math.ceil(id / 3)}`] }
+        };
+      });
+
+      const results = await processor.processTemplates(templates);
+
+      // Should have results from both batches (6 templates, batchSize=3)
+      expect(results.size).toBeGreaterThan(0);
+      expect(mockClient.batches.create).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle empty batch results', async () => {
+      const templates = [
+        { templateId: 1, name: 'T1', nodes: ['node'] },
+        { templateId: 2, name: 'T2', nodes: ['node'] }
+      ];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      const completedJob = {
+        id: 'batch-123',
+        status: 'completed',
+        output_file_id: 'output-123'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      // Return empty content
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve('')
+      });
+
+      const results = await processor.processTemplates(templates);
+
+      // Should handle empty results gracefully
+      expect(results.size).toBe(0);
+    });
+  });
+
+  describe('sleep', () => {
+    it('should delay for specified milliseconds', async () => {
+      const start = Date.now();
+      await (processor as any).sleep(100);
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeGreaterThanOrEqual(95);
+      expect(elapsed).toBeLessThan(150);
+    });
+  });
+
+  describe('processBatch (legacy method)', () => {
+    it('should process a single batch synchronously', async () => {
+      const templates = [
+        { templateId: 1, name: 'Test1', nodes: ['node1'] },
+        { templateId: 2, name: 'Test2', nodes: ['node2'] }
+      ];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-abc' });
+      const completedJob = {
+        id: 'batch-xyz',
+        status: 'completed',
+        output_file_id: 'output-xyz'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+
+      const fileContent = '{"custom_id": "template-1"}\n{"custom_id": "template-2"}';
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve(fileContent)
+      });
+
+      const mockResults = [
+        { templateId: 1, metadata: { categories: ['test1'] } },
+        { templateId: 2, metadata: { categories: ['test2'] } }
+      ];
+      mockGenerator.parseResult.mockReturnValueOnce(mockResults[0])
+                                .mockReturnValueOnce(mockResults[1]);
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      const results = await (processor as any).processBatch(templates, 'legacy_test');
+
+      expect(results).toHaveLength(2);
+      expect(results[0].templateId).toBe(1);
+      expect(results[1].templateId).toBe(2);
+      expect(mockClient.batches.create).toHaveBeenCalled();
+    });
+
+    it('should clean up files after processing', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-clean' });
+      const completedJob = {
+        id: 'batch-clean',
+        status: 'completed',
+        output_file_id: 'output-clean'
+      };
+      mockClient.batches.create.mockResolvedValue(completedJob);
+      mockClient.batches.retrieve.mockResolvedValue(completedJob);
+      mockClient.files.content.mockResolvedValue({
+        text: () => Promise.resolve('{"custom_id": "template-1"}')
+      });
+      mockGenerator.parseResult.mockReturnValue({
+        templateId: 1,
+        metadata: { categories: ['test'] }
+      });
+
+      // Mock sleep to speed up test
+      (processor as any).sleep = vi.fn().mockResolvedValue(undefined);
+
+      await (processor as any).processBatch(templates, 'cleanup_test');
+
+      // Should clean up all files
+      expect(mockedFs.unlinkSync).toHaveBeenCalled();
+      expect(mockClient.files.del).toHaveBeenCalledWith('file-clean');
+      expect(mockClient.files.del).toHaveBeenCalledWith('output-clean');
+    });
+
+    it('should clean up local file on error', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockRejectedValue(new Error('Upload failed'));
+
+      await expect(
+        (processor as any).processBatch(templates, 'error_test')
+      ).rejects.toThrow('Upload failed');
+
+      // Should clean up local file even on error
+      expect(mockedFs.unlinkSync).toHaveBeenCalled();
+    });
+
+    it('should handle batch job monitoring errors', async () => {
+      const templates = [{ templateId: 1, name: 'Test', nodes: ['node1'] }];
+
+      mockClient.files.create.mockResolvedValue({ id: 'file-123' });
+      mockClient.batches.create.mockResolvedValue({ id: 'batch-123' });
+      mockClient.batches.retrieve.mockResolvedValue({
+        id: 'batch-123',
+        status: 'failed'
+      });
+
+      await expect(
+        (processor as any).processBatch(templates, 'failed_batch')
+      ).rejects.toThrow('Batch job failed with status: failed');
+
+      // Should still attempt cleanup
+      expect(mockedFs.unlinkSync).toHaveBeenCalled();
+    });
+  });
 });

tests/unit/templates/metadata-generator.test.ts

@@ -18,7 +18,7 @@ describe('MetadataGenerator', () => {
   let generator: MetadataGenerator;
   
   beforeEach(() => {
-    generator = new MetadataGenerator('test-api-key', 'gpt-4o-mini');
+    generator = new MetadataGenerator('test-api-key', 'gpt-5-mini-2025-08-07');
   });
   
   describe('createBatchRequest', () => {
@@ -35,7 +35,7 @@ describe('MetadataGenerator', () => {
       expect(request.custom_id).toBe('template-123');
       expect(request.method).toBe('POST');
       expect(request.url).toBe('/v1/chat/completions');
-      expect(request.body.model).toBe('gpt-4o-mini');
+      expect(request.body.model).toBe('gpt-5-mini-2025-08-07');
       expect(request.body.response_format.type).toBe('json_schema');
       expect(request.body.response_format.json_schema.strict).toBe(true);
       expect(request.body.messages).toHaveLength(2);
@@ -217,7 +217,7 @@ describe('MetadataGenerator', () => {
       // but should not cause any injection in our code
       expect(userMessage).toContain('<script>alert("xss")</script>');
       expect(userMessage).toContain('javascript:alert(1)');
-      expect(request.body.model).toBe('gpt-4o-mini');
+      expect(request.body.model).toBe('gpt-5-mini-2025-08-07');
     });
 
     it('should handle extremely long template names', () => {