mcp-adr-analysis-server 2.0.21 → 2.1.0

package/dist/src/index.js

@@ -8,14 +8,14 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import { getCurrentDirCompat } from './utils/directory-compat.js';
 import { McpAdrError } from './types/index.js';
 import { CONVERSATION_CONTEXT_SCHEMA } from './types/conversation-context.js';
-import { maskMcpResponse, createMaskingConfig } from './utils/output-masking.js';
-import { loadConfig, validateProjectPath, createLogger, printConfigSummary } from './utils/config.js';
+import { maskMcpResponse, createMaskingConfig, } from './utils/output-masking.js';
+import { loadConfig, validateProjectPath, createLogger, printConfigSummary, } from './utils/config.js';
 import { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
 /**
  * Get version from package.json
@@ -29,7 +29,7 @@ function getPackageVersion() {
             join(currentDir, 'package.json'),
             join(currentDir, '..', 'package.json'),
             join(currentDir, '..', '..', 'package.json'),
-            join(process.cwd(), 'package.json')
+            join(process.cwd(), 'package.json'),
         ];
         for (const packageJsonPath of possiblePaths) {
             try {
@@ -61,7 +61,7 @@ function getPackageVersion() {
 const SERVER_INFO = {
     name: 'mcp-adr-analysis-server',
     version: getPackageVersion(),
-    description: 'MCP server for analyzing Architectural Decision Records and project architecture'
+    description: 'MCP server for analyzing Architectural Decision Records and project architecture',
 };
 /**
  * Main server class
@@ -84,8 +84,8 @@ export class McpAdrAnalysisServer {
             capabilities: {
                 tools: {},
                 resources: {},
-                prompts: {}
-            }
+                prompts: {},
+            },
         });
         this.maskingConfig = createMaskingConfig();
         this.setupHandlers();
@@ -99,7 +99,8 @@ export class McpAdrAnalysisServer {
             this.logger.info(`Project path validated: ${this.config.projectPath}`);
         }
         catch (error) {
-            this.logger.error(`Configuration validation failed: ${error.message}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Configuration validation failed: ${errorMessage}`);
             throw error;
         }
     }
@@ -126,59 +127,59 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to the project directory to analyze (optional, uses configured PROJECT_PATH if not provided)'
+                                    description: 'Path to the project directory to analyze (optional, uses configured PROJECT_PATH if not provided)',
                                 },
                                 includePatterns: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'File patterns to include in analysis'
+                                    description: 'File patterns to include in analysis',
                                 },
                                 enhancedMode: {
                                     type: 'boolean',
                                     description: 'Enable advanced prompting features (Knowledge Generation + Reflexion)',
-                                    default: true
+                                    default: true,
                                 },
                                 knowledgeEnhancement: {
                                     type: 'boolean',
                                     description: 'Enable Knowledge Generation for technology-specific insights',
-                                    default: true
+                                    default: true,
                                 },
                                 learningEnabled: {
                                     type: 'boolean',
                                     description: 'Enable Reflexion learning from past analysis outcomes',
-                                    default: true
+                                    default: true,
                                 },
                                 technologyFocus: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Specific technologies to focus analysis on (auto-detected if not provided)'
+                                    description: 'Specific technologies to focus analysis on (auto-detected if not provided)',
                                 },
                                 analysisDepth: {
                                     type: 'string',
                                     enum: ['basic', 'detailed', 'comprehensive'],
                                     description: 'Depth of ecosystem analysis',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 includeEnvironment: {
                                     type: 'boolean',
                                     description: 'Automatically include comprehensive environment analysis (default: true)',
-                                    default: true
+                                    default: true,
                                 },
                                 recursiveDepth: {
                                     type: 'string',
                                     description: 'Depth of recursive project analysis',
                                     enum: ['shallow', 'moderate', 'deep', 'comprehensive'],
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 analysisScope: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Specific analysis areas to focus on (e.g., ["security", "performance", "architecture", "dependencies"])'
+                                    description: 'Specific analysis areas to focus on (e.g., ["security", "performance", "architecture", "dependencies"])',
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
                             },
-                            required: []
-                        }
+                            required: [],
+                        },
                     },
                     {
                         name: 'get_architectural_context',
@@ -188,16 +189,16 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 filePath: {
                                     type: 'string',
-                                    description: 'Specific file path to analyze (optional, analyzes entire project if not provided)'
+                                    description: 'Specific file path to analyze (optional, analyzes entire project if not provided)',
                                 },
                                 includeCompliance: {
                                     type: 'boolean',
                                     description: 'Include compliance checks in the analysis',
-                                    default: true
+                                    default: true,
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
-                            }
-                        }
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
                     },
                     {
                         name: 'generate_adrs_from_prd',
@@ -207,37 +208,44 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 prdPath: {
                                     type: 'string',
-                                    description: 'Path to the PRD.md file'
+                                    description: 'Path to the PRD.md file',
                                 },
                                 outputDirectory: {
                                     type: 'string',
-                                    description: 'Directory to output generated ADRs (optional, uses configured ADR_DIRECTORY if not provided)'
+                                    description: 'Directory to output generated ADRs (optional, uses configured ADR_DIRECTORY if not provided)',
                                 },
                                 enhancedMode: {
                                     type: 'boolean',
                                     description: 'Enable advanced prompting features (APE + Knowledge Generation)',
-                                    default: true
+                                    default: true,
                                 },
                                 promptOptimization: {
                                     type: 'boolean',
                                     description: 'Enable Automatic Prompt Engineering for optimized ADR generation',
-                                    default: true
+                                    default: true,
                                 },
                                 knowledgeEnhancement: {
                                     type: 'boolean',
                                     description: 'Enable Knowledge Generation for domain-specific insights',
-                                    default: true
+                                    default: true,
                                 },
                                 prdType: {
                                     type: 'string',
-                                    enum: ['web-application', 'mobile-app', 'microservices', 'data-platform', 'api-service', 'general'],
+                                    enum: [
+                                        'web-application',
+                                        'mobile-app',
+                                        'microservices',
+                                        'data-platform',
+                                        'api-service',
+                                        'general',
+                                    ],
                                     description: 'Type of PRD for optimized knowledge generation',
-                                    default: 'general'
+                                    default: 'general',
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
                             },
-                            required: ['prdPath']
-                        }
+                            required: ['prdPath'],
+                        },
                     },
                     {
                         name: 'generate_adr_todo',
@@ -247,63 +255,63 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 adrDirectory: {
                                     type: 'string',
-                                    description: 'Directory containing ADR files (optional, uses configured ADR_DIRECTORY if not provided)'
+                                    description: 'Directory containing ADR files (optional, uses configured ADR_DIRECTORY if not provided)',
                                 },
                                 scope: {
                                     type: 'string',
                                     enum: ['all', 'pending', 'in_progress'],
                                     description: 'Scope of tasks to include',
-                                    default: 'all'
+                                    default: 'all',
                                 },
                                 phase: {
                                     type: 'string',
                                     enum: ['both', 'test', 'production'],
                                     description: 'TDD phase: both (default), test (mock test generation), production (implementation after tests)',
-                                    default: 'both'
+                                    default: 'both',
                                 },
                                 linkAdrs: {
                                     type: 'boolean',
                                     description: 'Auto-detect and link ADR dependencies in task creation',
-                                    default: true
+                                    default: true,
                                 },
                                 includeRules: {
                                     type: 'boolean',
                                     description: 'Include architectural rules validation in TDD tasks',
-                                    default: true
+                                    default: true,
                                 },
                                 ruleSource: {
                                     type: 'string',
                                     enum: ['adrs', 'patterns', 'both'],
                                     description: 'Source for architectural rules (only used if includeRules is true)',
-                                    default: 'both'
+                                    default: 'both',
                                 },
                                 todoPath: {
                                     type: 'string',
                                     description: 'Path to TODO.md file (relative to project root)',
-                                    default: 'TODO.md'
+                                    default: 'TODO.md',
                                 },
                                 preserveExisting: {
                                     type: 'boolean',
                                     description: 'Preserve existing TODO.md content by merging instead of overwriting',
-                                    default: true
+                                    default: true,
                                 },
                                 forceSyncToMarkdown: {
                                     type: 'boolean',
                                     description: 'Force sync JSON to markdown even if markdown is newer',
-                                    default: false
+                                    default: false,
                                 },
                                 intentId: {
                                     type: 'string',
-                                    description: 'Link generated tasks to specific knowledge graph intent'
+                                    description: 'Link generated tasks to specific knowledge graph intent',
                                 },
                                 createJsonBackup: {
                                     type: 'boolean',
                                     description: 'Create backup of existing JSON TODO data before import',
-                                    default: true
+                                    default: true,
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
-                            }
-                        }
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
                     },
                     {
                         name: 'compare_adr_progress',
@@ -314,23 +322,23 @@ export class McpAdrAnalysisServer {
                                 todoPath: {
                                     type: 'string',
                                     description: 'Path to TODO.md file to analyze',
-                                    default: 'TODO.md'
+                                    default: 'TODO.md',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory containing ADR files',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 projectPath: {
                                     type: 'string',
                                     description: 'Path to project root for environment analysis',
-                                    default: '.'
+                                    default: '.',
                                 },
                                 environment: {
                                     type: 'string',
                                     enum: ['development', 'staging', 'production', 'testing', 'auto-detect'],
                                     description: 'Target environment context for validation (auto-detect will infer from project structure)',
-                                    default: 'auto-detect'
+                                    default: 'auto-detect',
                                 },
                                 environmentConfig: {
                                     type: 'object',
@@ -339,87 +347,102 @@ export class McpAdrAnalysisServer {
                                         requiredFiles: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Files required for this environment'
+                                            description: 'Files required for this environment',
                                         },
                                         requiredServices: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Services that must be implemented for this environment'
+                                            description: 'Services that must be implemented for this environment',
                                         },
                                         securityLevel: {
                                             type: 'string',
                                             enum: ['low', 'medium', 'high', 'critical'],
-                                            description: 'Required security level for this environment'
+                                            description: 'Required security level for this environment',
                                         },
                                         performanceRequirements: {
                                             type: 'object',
-                                            description: 'Performance requirements for this environment'
-                                        }
-                                    }
+                                            description: 'Performance requirements for this environment',
+                                        },
+                                    },
                                 },
                                 validationType: {
                                     type: 'string',
                                     enum: ['full', 'todo-only', 'adr-only', 'environment-only'],
                                     description: 'Type of validation to perform',
-                                    default: 'full'
+                                    default: 'full',
                                 },
                                 includeFileChecks: {
                                     type: 'boolean',
                                     description: 'Include file existence and implementation checks',
-                                    default: true
+                                    default: true,
                                 },
                                 includeRuleValidation: {
                                     type: 'boolean',
                                     description: 'Include architectural rule compliance validation',
-                                    default: true
+                                    default: true,
                                 },
                                 deepCodeAnalysis: {
                                     type: 'boolean',
                                     description: 'Perform deep code analysis to distinguish mock from production implementations',
-                                    default: true
+                                    default: true,
                                 },
                                 functionalValidation: {
                                     type: 'boolean',
                                     description: 'Validate that code actually functions according to ADR goals, not just exists',
-                                    default: true
+                                    default: true,
                                 },
                                 strictMode: {
                                     type: 'boolean',
                                     description: 'Enable strict validation mode with reality-check mechanisms against overconfident assessments',
-                                    default: true
+                                    default: true,
                                 },
                                 environmentValidation: {
                                     type: 'boolean',
                                     description: 'Enable environment-specific validation rules and checks',
-                                    default: true
-                                }
-                            }
-                        }
+                                    default: true,
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'analyze_content_security',
-                        description: 'Analyze content for sensitive information using AI-powered detection',
+                        description: 'Analyze content for sensitive information using AI-powered detection with optional memory integration for security pattern learning',
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 content: {
                                     type: 'string',
-                                    description: 'Content to analyze for sensitive information'
+                                    description: 'Content to analyze for sensitive information',
                                 },
                                 contentType: {
                                     type: 'string',
                                     enum: ['code', 'documentation', 'configuration', 'logs', 'general'],
                                     description: 'Type of content being analyzed',
-                                    default: 'general'
+                                    default: 'general',
                                 },
                                 userDefinedPatterns: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'User-defined sensitive patterns to detect'
-                                }
+                                    description: 'User-defined sensitive patterns to detect',
+                                },
+                                enableMemoryIntegration: {
+                                    type: 'boolean',
+                                    description: 'Enable memory entity storage for security pattern learning and institutional knowledge building',
+                                    default: true,
+                                },
+                                knowledgeEnhancement: {
+                                    type: 'boolean',
+                                    description: 'Enable Generated Knowledge Prompting for security and privacy expertise',
+                                    default: true,
+                                },
+                                enhancedMode: {
+                                    type: 'boolean',
+                                    description: 'Enable advanced prompting features',
+                                    default: true,
+                                },
                             },
-                            required: ['content']
-                        }
+                            required: ['content'],
+                        },
                     },
                     {
                         name: 'generate_content_masking',
@@ -429,7 +452,7 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 content: {
                                     type: 'string',
-                                    description: 'Content to mask'
+                                    description: 'Content to mask',
                                 },
                                 detectedItems: {
                                     type: 'array',
@@ -440,20 +463,20 @@ export class McpAdrAnalysisServer {
                                             content: { type: 'string' },
                                             startPosition: { type: 'number' },
                                             endPosition: { type: 'number' },
-                                            severity: { type: 'string' }
-                                        }
+                                            severity: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Detected sensitive items to mask'
+                                    description: 'Detected sensitive items to mask',
                                 },
                                 maskingStrategy: {
                                     type: 'string',
                                     enum: ['full', 'partial', 'placeholder', 'environment'],
                                     description: 'Strategy for masking content',
-                                    default: 'full'
-                                }
+                                    default: 'full',
+                                },
                             },
-                            required: ['content', 'detectedItems']
-                        }
+                            required: ['content', 'detectedItems'],
+                        },
                     },
                     {
                         name: 'configure_custom_patterns',
@@ -463,16 +486,16 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to the project directory'
+                                    description: 'Path to the project directory',
                                 },
                                 existingPatterns: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Existing patterns to consider'
-                                }
+                                    description: 'Existing patterns to consider',
+                                },
                             },
-                            required: ['projectPath']
-                        }
+                            required: ['projectPath'],
+                        },
                     },
                     {
                         name: 'apply_basic_content_masking',
@@ -482,17 +505,17 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 content: {
                                     type: 'string',
-                                    description: 'Content to mask'
+                                    description: 'Content to mask',
                                 },
                                 maskingStrategy: {
                                     type: 'string',
                                     enum: ['full', 'partial', 'placeholder'],
                                     description: 'Strategy for masking content',
-                                    default: 'full'
-                                }
+                                    default: 'full',
+                                },
                             },
-                            required: ['content']
-                        }
+                            required: ['content'],
+                        },
                     },
                     {
                         name: 'validate_content_masking',
@@ -502,15 +525,15 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 originalContent: {
                                     type: 'string',
-                                    description: 'Original content before masking'
+                                    description: 'Original content before masking',
                                 },
                                 maskedContent: {
                                     type: 'string',
-                                    description: 'Content after masking'
-                                }
+                                    description: 'Content after masking',
+                                },
                             },
-                            required: ['originalContent', 'maskedContent']
-                        }
+                            required: ['originalContent', 'maskedContent'],
+                        },
                     },
                     {
                         name: 'manage_cache',
@@ -521,15 +544,15 @@ export class McpAdrAnalysisServer {
                                 action: {
                                     type: 'string',
                                     enum: ['clear', 'stats', 'cleanup', 'invalidate'],
-                                    description: 'Cache management action to perform'
+                                    description: 'Cache management action to perform',
                                 },
                                 key: {
                                     type: 'string',
-                                    description: 'Specific cache key to invalidate (for invalidate action)'
-                                }
+                                    description: 'Specific cache key to invalidate (for invalidate action)',
+                                },
                             },
-                            required: ['action']
-                        }
+                            required: ['action'],
+                        },
                     },
                     {
                         name: 'configure_output_masking',
@@ -539,26 +562,26 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 enabled: {
                                     type: 'boolean',
-                                    description: 'Enable or disable output masking'
+                                    description: 'Enable or disable output masking',
                                 },
                                 strategy: {
                                     type: 'string',
                                     enum: ['full', 'partial', 'placeholder', 'environment'],
-                                    description: 'Masking strategy to use'
+                                    description: 'Masking strategy to use',
                                 },
                                 customPatterns: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Custom patterns to mask'
+                                    description: 'Custom patterns to mask',
                                 },
                                 action: {
                                     type: 'string',
                                     enum: ['get', 'set', 'reset'],
                                     description: 'Configuration action',
-                                    default: 'get'
-                                }
-                            }
-                        }
+                                    default: 'get',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'suggest_adrs',
@@ -569,54 +592,54 @@ export class McpAdrAnalysisServer {
                                 projectPath: {
                                     type: 'string',
                                     description: 'Path to the project directory',
-                                    default: '.'
+                                    default: '.',
                                 },
                                 analysisType: {
                                     type: 'string',
                                     enum: ['implicit_decisions', 'code_changes', 'comprehensive'],
                                     description: 'Type of analysis to perform',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 beforeCode: {
                                     type: 'string',
-                                    description: 'Code before changes (for code_changes analysis)'
+                                    description: 'Code before changes (for code_changes analysis)',
                                 },
                                 afterCode: {
                                     type: 'string',
-                                    description: 'Code after changes (for code_changes analysis)'
+                                    description: 'Code after changes (for code_changes analysis)',
                                 },
                                 changeDescription: {
                                     type: 'string',
-                                    description: 'Description of the changes (for code_changes analysis)'
+                                    description: 'Description of the changes (for code_changes analysis)',
                                 },
                                 commitMessages: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Related commit messages (for code_changes analysis)'
+                                    description: 'Related commit messages (for code_changes analysis)',
                                 },
                                 existingAdrs: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'List of existing ADR titles to avoid duplication'
+                                    description: 'List of existing ADR titles to avoid duplication',
                                 },
                                 enhancedMode: {
                                     type: 'boolean',
                                     description: 'Enable advanced prompting features (Knowledge Generation + Reflexion)',
-                                    default: true
+                                    default: true,
                                 },
                                 learningEnabled: {
                                     type: 'boolean',
                                     description: 'Enable Reflexion learning from past experiences',
-                                    default: true
+                                    default: true,
                                 },
                                 knowledgeEnhancement: {
                                     type: 'boolean',
                                     description: 'Enable Knowledge Generation for domain-specific insights',
-                                    default: true
+                                    default: true,
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
-                            }
-                        }
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
                     },
                     {
                         name: 'generate_adr_from_decision',
@@ -634,35 +657,81 @@ export class McpAdrAnalysisServer {
                                         alternatives: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Alternative approaches considered'
+                                            description: 'Alternative approaches considered',
                                         },
                                         evidence: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Supporting evidence for the decision'
-                                        }
+                                            description: 'Supporting evidence for the decision',
+                                        },
                                     },
-                                    required: ['title', 'context', 'decision', 'consequences']
+                                    required: ['title', 'context', 'decision', 'consequences'],
                                 },
                                 templateFormat: {
                                     type: 'string',
                                     enum: ['nygard', 'madr', 'custom'],
                                     description: 'ADR template format to use',
-                                    default: 'nygard'
+                                    default: 'nygard',
                                 },
                                 existingAdrs: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'List of existing ADRs for numbering and references'
+                                    description: 'List of existing ADRs for numbering and references',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory where ADRs are stored',
-                                    default: 'docs/adrs'
-                                }
+                                    default: 'docs/adrs',
+                                },
                             },
-                            required: ['decisionData']
-                        }
+                            required: ['decisionData'],
+                        },
+                    },
+                    {
+                        name: 'generate_adr_bootstrap',
+                        description: 'Generate bootstrap.sh and validate_bootstrap.sh scripts to ensure deployed code follows ADR requirements',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to the project directory',
+                                    default: '.',
+                                },
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'Directory where ADRs are stored',
+                                    default: 'docs/adrs',
+                                },
+                                outputPath: {
+                                    type: 'string',
+                                    description: 'Directory where to generate scripts',
+                                    default: '.',
+                                },
+                                scriptType: {
+                                    type: 'string',
+                                    enum: ['bootstrap', 'validate', 'both'],
+                                    description: 'Which scripts to generate',
+                                    default: 'both',
+                                },
+                                includeTests: {
+                                    type: 'boolean',
+                                    description: 'Include test execution in bootstrap',
+                                    default: true,
+                                },
+                                includeDeployment: {
+                                    type: 'boolean',
+                                    description: 'Include deployment steps in bootstrap',
+                                    default: true,
+                                },
+                                customValidations: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Custom validation commands to include',
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
                     },
                     {
                         name: 'discover_existing_adrs',
@@ -673,15 +742,55 @@ export class McpAdrAnalysisServer {
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory to search for ADRs',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 includeContent: {
                                     type: 'boolean',
                                     description: 'Whether to include ADR content in analysis',
-                                    default: false
-                                }
-                            }
-                        }
+                                    default: false,
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'review_existing_adrs',
+                        description: 'Review existing ADRs against actual code implementation with cloud/DevOps expertise',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'Directory containing ADR files',
+                                    default: 'docs/adrs',
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to the project directory',
+                                    default: '.',
+                                },
+                                specificAdr: {
+                                    type: 'string',
+                                    description: 'Specific ADR filename or title to review (optional)',
+                                },
+                                analysisDepth: {
+                                    type: 'string',
+                                    enum: ['basic', 'detailed', 'comprehensive'],
+                                    description: 'Depth of analysis to perform',
+                                    default: 'detailed',
+                                },
+                                includeTreeSitter: {
+                                    type: 'boolean',
+                                    description: 'Use tree-sitter for enhanced code analysis',
+                                    default: true,
+                                },
+                                generateUpdatePlan: {
+                                    type: 'boolean',
+                                    description: 'Generate action plan for updating non-compliant ADRs',
+                                    default: true,
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
+                            },
+                        },
                     },
                     {
                         name: 'incorporate_research',
@@ -692,23 +801,29 @@ export class McpAdrAnalysisServer {
                                 researchPath: {
                                     type: 'string',
                                     description: 'Path to research directory',
-                                    default: 'docs/research'
+                                    default: 'docs/research',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Path to ADR directory',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 analysisType: {
                                     type: 'string',
-                                    enum: ['monitor', 'extract_topics', 'evaluate_impact', 'generate_updates', 'comprehensive'],
+                                    enum: [
+                                        'monitor',
+                                        'extract_topics',
+                                        'evaluate_impact',
+                                        'generate_updates',
+                                        'comprehensive',
+                                    ],
                                     description: 'Type of research analysis to perform',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 existingTopics: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Previously identified research topics'
+                                    description: 'Previously identified research topics',
                                 },
                                 researchTopics: {
                                     type: 'array',
@@ -719,19 +834,19 @@ export class McpAdrAnalysisServer {
                                             title: { type: 'string' },
                                             category: { type: 'string' },
                                             keyFindings: { type: 'array', items: { type: 'string' } },
-                                            relevanceScore: { type: 'number' }
-                                        }
+                                            relevanceScore: { type: 'number' },
+                                        },
                                     },
-                                    description: 'Research topics for impact evaluation'
+                                    description: 'Research topics for impact evaluation',
                                 },
                                 adrId: {
                                     type: 'string',
-                                    description: 'ADR ID for update generation'
+                                    description: 'ADR ID for update generation',
                                 },
                                 updateType: {
                                     type: 'string',
                                     enum: ['content', 'status', 'consequences', 'alternatives', 'deprecation'],
-                                    description: 'Type of ADR update to generate'
+                                    description: 'Type of ADR update to generate',
                                 },
                                 researchFindings: {
                                     type: 'array',
@@ -740,13 +855,13 @@ export class McpAdrAnalysisServer {
                                         properties: {
                                             finding: { type: 'string' },
                                             evidence: { type: 'array', items: { type: 'string' } },
-                                            impact: { type: 'string' }
-                                        }
+                                            impact: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Research findings for update generation'
-                                }
-                            }
-                        }
+                                    description: 'Research findings for update generation',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'create_research_template',
@@ -756,21 +871,21 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 title: {
                                     type: 'string',
-                                    description: 'Title of the research'
+                                    description: 'Title of the research',
                                 },
                                 category: {
                                     type: 'string',
                                     description: 'Research category',
-                                    default: 'general'
+                                    default: 'general',
                                 },
                                 researchPath: {
                                     type: 'string',
                                     description: 'Path to research directory',
-                                    default: 'docs/research'
-                                }
+                                    default: 'docs/research',
+                                },
                             },
-                            required: ['title']
-                        }
+                            required: ['title'],
+                        },
                     },
                     {
                         name: 'request_action_confirmation',
@@ -780,21 +895,21 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 action: {
                                     type: 'string',
-                                    description: 'Description of the action to be performed'
+                                    description: 'Description of the action to be performed',
                                 },
                                 details: {
                                     type: 'string',
-                                    description: 'Detailed information about the action'
+                                    description: 'Detailed information about the action',
                                 },
                                 impact: {
                                     type: 'string',
                                     enum: ['low', 'medium', 'high', 'critical'],
                                     description: 'Impact level of the action',
-                                    default: 'medium'
-                                }
+                                    default: 'medium',
+                                },
                             },
-                            required: ['action', 'details']
-                        }
+                            required: ['action', 'details'],
+                        },
                     },
                     {
                         name: 'generate_rules',
@@ -806,17 +921,17 @@ export class McpAdrAnalysisServer {
                                     type: 'string',
                                     enum: ['adrs', 'patterns', 'both'],
                                     description: 'Source for rule generation',
-                                    default: 'both'
+                                    default: 'both',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory containing ADR files',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 projectPath: {
                                     type: 'string',
                                     description: 'Path to project for pattern analysis',
-                                    default: '.'
+                                    default: '.',
                                 },
                                 existingRules: {
                                     type: 'array',
@@ -825,19 +940,19 @@ export class McpAdrAnalysisServer {
                                         properties: {
                                             id: { type: 'string' },
                                             name: { type: 'string' },
-                                            description: { type: 'string' }
-                                        }
+                                            description: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Existing rules to avoid duplication'
+                                    description: 'Existing rules to avoid duplication',
                                 },
                                 outputFormat: {
                                     type: 'string',
                                     enum: ['json', 'yaml', 'both'],
                                     description: 'Output format for rules',
-                                    default: 'json'
-                                }
-                            }
-                        }
+                                    default: 'json',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'validate_rules',
@@ -847,15 +962,15 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 filePath: {
                                     type: 'string',
-                                    description: 'Path to file to validate'
+                                    description: 'Path to file to validate',
                                 },
                                 fileContent: {
                                     type: 'string',
-                                    description: 'Content to validate (alternative to filePath)'
+                                    description: 'Content to validate (alternative to filePath)',
                                 },
                                 fileName: {
                                     type: 'string',
-                                    description: 'Name of file being validated (when using fileContent)'
+                                    description: 'Name of file being validated (when using fileContent)',
                                 },
                                 rules: {
                                     type: 'array',
@@ -867,27 +982,27 @@ export class McpAdrAnalysisServer {
                                             description: { type: 'string' },
                                             pattern: { type: 'string' },
                                             severity: { type: 'string' },
-                                            message: { type: 'string' }
+                                            message: { type: 'string' },
                                         },
-                                        required: ['id', 'name', 'pattern', 'severity', 'message']
+                                        required: ['id', 'name', 'pattern', 'severity', 'message'],
                                     },
-                                    description: 'Rules to validate against'
+                                    description: 'Rules to validate against',
                                 },
                                 validationType: {
                                     type: 'string',
                                     enum: ['file', 'function', 'component', 'module'],
                                     description: 'Type of validation to perform',
-                                    default: 'file'
+                                    default: 'file',
                                 },
                                 reportFormat: {
                                     type: 'string',
                                     enum: ['summary', 'detailed', 'json'],
                                     description: 'Format for validation report',
-                                    default: 'detailed'
-                                }
+                                    default: 'detailed',
+                                },
                             },
-                            required: ['rules']
-                        }
+                            required: ['rules'],
+                        },
                     },
                     {
                         name: 'create_rule_set',
@@ -897,80 +1012,96 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 name: {
                                     type: 'string',
-                                    description: 'Name of the rule set'
+                                    description: 'Name of the rule set',
                                 },
                                 description: {
                                     type: 'string',
                                     description: 'Description of the rule set',
-                                    default: 'Generated architectural rule set'
+                                    default: 'Generated architectural rule set',
                                 },
                                 adrRules: {
                                     type: 'array',
                                     items: { type: 'object' },
-                                    description: 'Rules extracted from ADRs'
+                                    description: 'Rules extracted from ADRs',
                                 },
                                 patternRules: {
                                     type: 'array',
                                     items: { type: 'object' },
-                                    description: 'Rules generated from code patterns'
+                                    description: 'Rules generated from code patterns',
                                 },
                                 rules: {
                                     type: 'array',
                                     items: { type: 'object' },
-                                    description: 'Additional rules to include'
+                                    description: 'Additional rules to include',
                                 },
                                 outputFormat: {
                                     type: 'string',
                                     enum: ['json', 'yaml', 'both'],
                                     description: 'Output format for rule set',
-                                    default: 'json'
+                                    default: 'json',
                                 },
                                 author: {
                                     type: 'string',
                                     description: 'Author of the rule set',
-                                    default: 'MCP ADR Analysis Server'
-                                }
+                                    default: 'MCP ADR Analysis Server',
+                                },
                             },
-                            required: ['name']
-                        }
+                            required: ['name'],
+                        },
                     },
                     {
                         name: 'analyze_environment',
-                        description: 'Analyze environment context and provide optimization recommendations',
+                        description: 'Analyze environment context and provide optimization recommendations with optional memory integration for environment snapshot tracking',
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 projectPath: {
                                     type: 'string',
                                     description: 'Path to project directory',
-                                    default: '.'
+                                    default: '.',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory containing ADR files',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 analysisType: {
                                     type: 'string',
-                                    enum: ['specs', 'containerization', 'requirements', 'compliance', 'comprehensive'],
+                                    enum: [
+                                        'specs',
+                                        'containerization',
+                                        'requirements',
+                                        'compliance',
+                                        'comprehensive',
+                                    ],
                                     description: 'Type of environment analysis to perform',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 currentEnvironment: {
                                     type: 'object',
-                                    description: 'Current environment specifications (for compliance analysis)'
+                                    description: 'Current environment specifications (for compliance analysis)',
                                 },
                                 requirements: {
                                     type: 'object',
-                                    description: 'Environment requirements (for compliance analysis)'
+                                    description: 'Environment requirements (for compliance analysis)',
                                 },
                                 industryStandards: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Industry standards to assess compliance against'
-                                }
-                            }
-                        }
+                                    description: 'Industry standards to assess compliance against',
+                                },
+                                enableMemoryIntegration: {
+                                    type: 'boolean',
+                                    description: 'Enable memory entity storage for environment snapshot tracking and historical analysis',
+                                    default: true,
+                                },
+                                enableTrendAnalysis: {
+                                    type: 'boolean',
+                                    description: 'Enable analysis of environment changes over time using stored snapshots',
+                                    default: true,
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'generate_research_questions',
@@ -982,7 +1113,7 @@ export class McpAdrAnalysisServer {
                                     type: 'string',
                                     enum: ['correlation', 'relevance', 'questions', 'tracking', 'comprehensive'],
                                     description: 'Type of research analysis to perform',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 researchContext: {
                                     type: 'object',
@@ -992,9 +1123,9 @@ export class McpAdrAnalysisServer {
                                         scope: { type: 'string' },
                                         objectives: { type: 'array', items: { type: 'string' } },
                                         constraints: { type: 'array', items: { type: 'string' } },
-                                        timeline: { type: 'string' }
+                                        timeline: { type: 'string' },
                                     },
-                                    description: 'Research context and objectives'
+                                    description: 'Research context and objectives',
                                 },
                                 problems: {
                                     type: 'array',
@@ -1005,10 +1136,10 @@ export class McpAdrAnalysisServer {
                                             description: { type: 'string' },
                                             category: { type: 'string' },
                                             severity: { type: 'string' },
-                                            context: { type: 'string' }
-                                        }
+                                            context: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Problems to correlate with knowledge graph'
+                                    description: 'Problems to correlate with knowledge graph',
                                 },
                                 knowledgeGraph: {
                                     type: 'object',
@@ -1016,9 +1147,9 @@ export class McpAdrAnalysisServer {
                                         technologies: { type: 'array', items: { type: 'object' } },
                                         patterns: { type: 'array', items: { type: 'object' } },
                                         adrs: { type: 'array', items: { type: 'object' } },
-                                        relationships: { type: 'array', items: { type: 'object' } }
+                                        relationships: { type: 'array', items: { type: 'object' } },
                                     },
-                                    description: 'Architectural knowledge graph'
+                                    description: 'Architectural knowledge graph',
                                 },
                                 relevantKnowledge: {
                                     type: 'object',
@@ -1026,9 +1157,9 @@ export class McpAdrAnalysisServer {
                                         adrs: { type: 'array', items: { type: 'object' } },
                                         patterns: { type: 'array', items: { type: 'object' } },
                                         gaps: { type: 'array', items: { type: 'object' } },
-                                        opportunities: { type: 'array', items: { type: 'object' } }
+                                        opportunities: { type: 'array', items: { type: 'object' } },
                                     },
-                                    description: 'Relevant knowledge for question generation'
+                                    description: 'Relevant knowledge for question generation',
                                 },
                                 researchQuestions: {
                                     type: 'array',
@@ -1040,10 +1171,10 @@ export class McpAdrAnalysisServer {
                                             type: { type: 'string' },
                                             priority: { type: 'string' },
                                             timeline: { type: 'string' },
-                                            methodology: { type: 'string' }
-                                        }
+                                            methodology: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Research questions for task tracking'
+                                    description: 'Research questions for task tracking',
                                 },
                                 currentProgress: {
                                     type: 'array',
@@ -1054,23 +1185,23 @@ export class McpAdrAnalysisServer {
                                             status: { type: 'string' },
                                             progress: { type: 'number' },
                                             findings: { type: 'array', items: { type: 'string' } },
-                                            blockers: { type: 'array', items: { type: 'string' } }
-                                        }
+                                            blockers: { type: 'array', items: { type: 'string' } },
+                                        },
                                     },
-                                    description: 'Current research progress'
+                                    description: 'Current research progress',
                                 },
                                 projectPath: {
                                     type: 'string',
                                     description: 'Path to project directory',
-                                    default: '.'
+                                    default: '.',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory containing ADR files',
-                                    default: 'docs/adrs'
-                                }
-                            }
-                        }
+                                    default: 'docs/adrs',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'analyze_deployment_progress',
@@ -1082,25 +1213,25 @@ export class McpAdrAnalysisServer {
                                     type: 'string',
                                     enum: ['tasks', 'cicd', 'progress', 'completion', 'comprehensive'],
                                     description: 'Type of deployment analysis to perform',
-                                    default: 'comprehensive'
+                                    default: 'comprehensive',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'Directory containing ADR files',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 todoPath: {
                                     type: 'string',
                                     description: 'Path to TODO.md file for task identification',
-                                    default: 'TODO.md'
+                                    default: 'TODO.md',
                                 },
                                 cicdLogs: {
                                     type: 'string',
-                                    description: 'CI/CD pipeline logs for analysis'
+                                    description: 'CI/CD pipeline logs for analysis',
                                 },
                                 pipelineConfig: {
                                     type: 'string',
-                                    description: 'CI/CD pipeline configuration'
+                                    description: 'CI/CD pipeline configuration',
                                 },
                                 deploymentTasks: {
                                     type: 'array',
@@ -1114,10 +1245,10 @@ export class McpAdrAnalysisServer {
                                             category: { type: 'string' },
                                             priority: { type: 'string' },
                                             verificationCriteria: { type: 'array', items: { type: 'string' } },
-                                            expectedOutcome: { type: 'string' }
-                                        }
+                                            expectedOutcome: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Deployment tasks for progress calculation'
+                                    description: 'Deployment tasks for progress calculation',
                                 },
                                 outcomeRules: {
                                     type: 'array',
@@ -1127,10 +1258,10 @@ export class McpAdrAnalysisServer {
                                             ruleId: { type: 'string' },
                                             description: { type: 'string' },
                                             criteria: { type: 'array', items: { type: 'string' } },
-                                            verificationMethod: { type: 'string' }
-                                        }
+                                            verificationMethod: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Outcome rules for completion verification'
+                                    description: 'Outcome rules for completion verification',
                                 },
                                 actualOutcomes: {
                                     type: 'array',
@@ -1140,21 +1271,21 @@ export class McpAdrAnalysisServer {
                                             taskId: { type: 'string' },
                                             outcome: { type: 'string' },
                                             evidence: { type: 'array', items: { type: 'string' } },
-                                            timestamp: { type: 'string' }
-                                        }
+                                            timestamp: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Actual deployment outcomes'
+                                    description: 'Actual deployment outcomes',
                                 },
                                 cicdStatus: {
                                     type: 'object',
-                                    description: 'CI/CD pipeline status data'
+                                    description: 'CI/CD pipeline status data',
                                 },
                                 environmentStatus: {
                                     type: 'object',
-                                    description: 'Environment status data'
-                                }
-                            }
-                        }
+                                    description: 'Environment status data',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'check_ai_execution_status',
@@ -1162,8 +1293,8 @@ export class McpAdrAnalysisServer {
                         inputSchema: {
                             type: 'object',
                             properties: {},
-                            required: []
-                        }
+                            required: [],
+                        },
                     },
                     {
                         name: 'get_workflow_guidance',
@@ -1173,31 +1304,44 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 goal: {
                                     type: 'string',
-                                    description: 'What you want to accomplish (e.g., "analyze new project", "document existing decisions", "security audit", "modernize legacy system")'
+                                    description: 'What you want to accomplish (e.g., "analyze new project", "document existing decisions", "security audit", "modernize legacy system")',
                                 },
                                 projectContext: {
                                     type: 'string',
                                     description: 'Current state of your project (e.g., "new project", "existing project with ADRs", "legacy codebase", "greenfield development")',
-                                    enum: ['new_project', 'existing_with_adrs', 'existing_without_adrs', 'legacy_codebase', 'greenfield', 'maintenance_mode', 'unknown']
+                                    enum: [
+                                        'new_project',
+                                        'existing_with_adrs',
+                                        'existing_without_adrs',
+                                        'legacy_codebase',
+                                        'greenfield',
+                                        'maintenance_mode',
+                                        'unknown',
+                                    ],
                                 },
                                 availableAssets: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'What assets you already have (e.g., ["PRD.md", "existing ADRs", "codebase", "documentation", "test suite"])'
+                                    description: 'What assets you already have (e.g., ["PRD.md", "existing ADRs", "codebase", "documentation", "test suite"])',
                                 },
                                 timeframe: {
                                     type: 'string',
                                     description: 'Available time/effort level',
-                                    enum: ['quick_analysis', 'thorough_review', 'comprehensive_audit', 'ongoing_process']
+                                    enum: [
+                                        'quick_analysis',
+                                        'thorough_review',
+                                        'comprehensive_audit',
+                                        'ongoing_process',
+                                    ],
                                 },
                                 primaryConcerns: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Main areas of concern (e.g., ["security", "performance", "maintainability", "scalability", "compliance"])'
-                                }
+                                    description: 'Main areas of concern (e.g., ["security", "performance", "maintainability", "scalability", "compliance"])',
+                                },
                             },
-                            required: ['goal', 'projectContext']
-                        }
+                            required: ['goal', 'projectContext'],
+                        },
                     },
                     {
                         name: 'get_development_guidance',
@@ -1208,47 +1352,55 @@ export class McpAdrAnalysisServer {
                                 developmentPhase: {
                                     type: 'string',
                                     description: 'Current development phase',
-                                    enum: ['planning', 'setup', 'implementation', 'testing', 'deployment', 'maintenance', 'refactoring']
+                                    enum: [
+                                        'planning',
+                                        'setup',
+                                        'implementation',
+                                        'testing',
+                                        'deployment',
+                                        'maintenance',
+                                        'refactoring',
+                                    ],
                                 },
                                 adrsToImplement: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'List of ADR titles or file paths that need to be implemented in code'
+                                    description: 'List of ADR titles or file paths that need to be implemented in code',
                                 },
                                 technologyStack: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Current technology stack (e.g., ["TypeScript", "React", "Node.js", "PostgreSQL", "Docker"])'
+                                    description: 'Current technology stack (e.g., ["TypeScript", "React", "Node.js", "PostgreSQL", "Docker"])',
                                 },
                                 currentProgress: {
                                     type: 'string',
-                                    description: 'What has already been implemented or current state of development'
+                                    description: 'What has already been implemented or current state of development',
                                 },
                                 teamContext: {
                                     type: 'object',
                                     properties: {
                                         size: {
                                             type: 'string',
-                                            enum: ['solo', 'small_team', 'medium_team', 'large_team']
+                                            enum: ['solo', 'small_team', 'medium_team', 'large_team'],
                                         },
                                         experienceLevel: {
                                             type: 'string',
-                                            enum: ['junior', 'mixed', 'senior', 'expert']
-                                        }
-                                    }
+                                            enum: ['junior', 'mixed', 'senior', 'expert'],
+                                        },
+                                    },
                                 },
                                 timeline: {
                                     type: 'string',
-                                    description: 'Development timeline or deadline constraints'
+                                    description: 'Development timeline or deadline constraints',
                                 },
                                 focusAreas: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Specific areas to focus on (e.g., ["API design", "database schema", "testing strategy", "deployment pipeline"])'
-                                }
+                                    description: 'Specific areas to focus on (e.g., ["API design", "database schema", "testing strategy", "deployment pipeline"])',
+                                },
                             },
-                            required: ['developmentPhase']
-                        }
+                            required: ['developmentPhase'],
+                        },
                     },
                     {
                         name: 'read_file',
@@ -1258,11 +1410,11 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 path: {
                                     type: 'string',
-                                    description: 'Path to the file to read'
-                                }
+                                    description: 'Path to the file to read',
+                                },
                             },
-                            required: ['path']
-                        }
+                            required: ['path'],
+                        },
                     },
                     {
                         name: 'write_file',
@@ -1272,15 +1424,15 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 path: {
                                     type: 'string',
-                                    description: 'Path to the file to write'
+                                    description: 'Path to the file to write',
                                 },
                                 content: {
                                     type: 'string',
-                                    description: 'Content to write to the file'
-                                }
+                                    description: 'Content to write to the file',
+                                },
                             },
-                            required: ['path', 'content']
-                        }
+                            required: ['path', 'content'],
+                        },
                     },
                     {
                         name: 'list_directory',
@@ -1290,11 +1442,11 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 path: {
                                     type: 'string',
-                                    description: 'Path to the directory to list'
-                                }
+                                    description: 'Path to the directory to list',
+                                },
                             },
-                            required: ['path']
-                        }
+                            required: ['path'],
+                        },
                     },
                     {
                         name: 'manage_todo_json',
@@ -1304,175 +1456,191 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['create_task', 'update_task', 'bulk_update', 'get_tasks', 'get_analytics', 'import_adr_tasks', 'sync_knowledge_graph', 'sync_to_markdown', 'import_from_markdown'],
-                                    description: 'Operation to perform on TODO JSON backend'
+                                    enum: [
+                                        'create_task',
+                                        'update_task',
+                                        'bulk_update',
+                                        'get_tasks',
+                                        'get_analytics',
+                                        'import_adr_tasks',
+                                        'sync_knowledge_graph',
+                                        'sync_to_markdown',
+                                        'import_from_markdown',
+                                    ],
+                                    description: 'Operation to perform on TODO JSON backend',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Project root path (uses configured PROJECT_PATH if not provided)'
+                                    description: 'Project root path (uses configured PROJECT_PATH if not provided)',
                                 },
                                 taskId: {
                                     type: 'string',
-                                    description: 'Task ID for update operations'
+                                    description: 'Task ID for update operations',
                                 },
                                 title: {
                                     type: 'string',
-                                    description: 'Task title for create operations'
+                                    description: 'Task title for create operations',
                                 },
                                 description: {
                                     type: 'string',
-                                    description: 'Task description'
+                                    description: 'Task description',
                                 },
                                 priority: {
                                     type: 'string',
                                     enum: ['low', 'medium', 'high', 'critical'],
                                     default: 'medium',
-                                    description: 'Task priority level'
+                                    description: 'Task priority level',
                                 },
                                 assignee: {
                                     type: 'string',
-                                    description: 'Task assignee'
+                                    description: 'Task assignee',
                                 },
                                 dueDate: {
                                     type: 'string',
-                                    description: 'Due date (ISO string format)'
+                                    description: 'Due date (ISO string format)',
                                 },
                                 category: {
                                     type: 'string',
-                                    description: 'Task category'
+                                    description: 'Task category',
                                 },
                                 tags: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Task tags'
+                                    description: 'Task tags',
                                 },
                                 dependencies: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Task dependencies (task IDs)'
+                                    description: 'Task dependencies (task IDs)',
                                 },
                                 intentId: {
                                     type: 'string',
-                                    description: 'Link to knowledge graph intent'
+                                    description: 'Link to knowledge graph intent',
                                 },
                                 linkedAdrs: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Related ADR files'
+                                    description: 'Related ADR files',
                                 },
                                 autoComplete: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Auto-complete when criteria are met'
+                                    description: 'Auto-complete when criteria are met',
                                 },
                                 completionCriteria: {
                                     type: 'string',
-                                    description: 'Auto-completion rules'
+                                    description: 'Auto-completion rules',
                                 },
                                 updates: {
                                     type: 'object',
                                     properties: {
                                         title: { type: 'string' },
                                         description: { type: 'string' },
-                                        status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
+                                        status: {
+                                            type: 'string',
+                                            enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'],
+                                        },
                                         priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
                                         assignee: { type: 'string' },
                                         dueDate: { type: 'string' },
                                         progressPercentage: { type: 'number', minimum: 0, maximum: 100 },
                                         notes: { type: 'string' },
-                                        tags: { type: 'array', items: { type: 'string' } }
+                                        tags: { type: 'array', items: { type: 'string' } },
                                     },
-                                    description: 'Fields to update for update operations'
+                                    description: 'Fields to update for update operations',
                                 },
                                 reason: {
                                     type: 'string',
-                                    description: 'Reason for update (for changelog)'
+                                    description: 'Reason for update (for changelog)',
                                 },
                                 filters: {
                                     type: 'object',
                                     properties: {
-                                        status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
+                                        status: {
+                                            type: 'string',
+                                            enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'],
+                                        },
                                         priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
                                         assignee: { type: 'string' },
                                         category: { type: 'string' },
                                         hasDeadline: { type: 'boolean' },
                                         overdue: { type: 'boolean' },
-                                        tags: { type: 'array', items: { type: 'string' } }
+                                        tags: { type: 'array', items: { type: 'string' } },
                                     },
-                                    description: 'Filter criteria for get_tasks operation'
+                                    description: 'Filter criteria for get_tasks operation',
                                 },
                                 sortBy: {
                                     type: 'string',
                                     enum: ['priority', 'dueDate', 'createdAt', 'updatedAt'],
                                     default: 'priority',
-                                    description: 'Sort field for get_tasks operation'
+                                    description: 'Sort field for get_tasks operation',
                                 },
                                 sortOrder: {
                                     type: 'string',
                                     enum: ['asc', 'desc'],
                                     default: 'desc',
-                                    description: 'Sort order for get_tasks operation'
+                                    description: 'Sort order for get_tasks operation',
                                 },
                                 limit: {
                                     type: 'number',
-                                    description: 'Maximum number of tasks to return'
+                                    description: 'Maximum number of tasks to return',
                                 },
                                 timeframe: {
                                     type: 'string',
                                     enum: ['day', 'week', 'month', 'all'],
                                     default: 'week',
-                                    description: 'Analysis timeframe for analytics'
+                                    description: 'Analysis timeframe for analytics',
                                 },
                                 includeVelocity: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include velocity metrics in analytics'
+                                    description: 'Include velocity metrics in analytics',
                                 },
                                 includeScoring: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include scoring metrics in analytics'
+                                    description: 'Include scoring metrics in analytics',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     default: 'docs/adrs',
-                                    description: 'ADR directory path for imports'
+                                    description: 'ADR directory path for imports',
                                 },
                                 preserveExisting: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Keep existing tasks during imports'
+                                    description: 'Keep existing tasks during imports',
                                 },
                                 autoLinkDependencies: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Auto-detect task dependencies'
+                                    description: 'Auto-detect task dependencies',
                                 },
                                 direction: {
                                     type: 'string',
                                     enum: ['to_kg', 'from_kg', 'bidirectional'],
                                     default: 'bidirectional',
-                                    description: 'Knowledge graph sync direction'
+                                    description: 'Knowledge graph sync direction',
                                 },
                                 force: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Force operation even if conflicts exist'
+                                    description: 'Force operation even if conflicts exist',
                                 },
                                 mergeStrategy: {
                                     type: 'string',
                                     enum: ['overwrite', 'merge', 'preserve_json'],
                                     default: 'merge',
-                                    description: 'Merge strategy for imports'
+                                    description: 'Merge strategy for imports',
                                 },
                                 backupExisting: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Create backup before destructive operations'
-                                }
+                                    description: 'Create backup before destructive operations',
+                                },
                             },
-                            required: ['operation']
-                        }
+                            required: ['operation'],
+                        },
                     },
                     {
                         name: 'generate_deployment_guidance',
@@ -1483,65 +1651,75 @@ export class McpAdrAnalysisServer {
                                 adrDirectory: {
                                     type: 'string',
                                     default: 'docs/adrs',
-                                    description: 'Directory containing ADR files'
+                                    description: 'Directory containing ADR files',
                                 },
                                 environment: {
                                     type: 'string',
                                     enum: ['development', 'staging', 'production', 'all'],
                                     default: 'production',
-                                    description: 'Target deployment environment'
+                                    description: 'Target deployment environment',
                                 },
                                 format: {
                                     type: 'string',
                                     enum: ['markdown', 'scripts', 'structured', 'all'],
                                     default: 'markdown',
-                                    description: 'Output format for guidance'
+                                    description: 'Output format for guidance',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Project root path (optional, uses configured PROJECT_PATH if not provided)'
+                                    description: 'Project root path (optional, uses configured PROJECT_PATH if not provided)',
                                 },
                                 includeScripts: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Generate deployment scripts'
+                                    description: 'Generate deployment scripts',
                                 },
                                 includeConfigs: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Generate configuration files'
+                                    description: 'Generate configuration files',
                                 },
                                 includeValidation: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include validation and health checks'
+                                    description: 'Include validation and health checks',
                                 },
                                 technologyFilter: {
                                     type: 'array',
                                     items: {
                                         type: 'string',
-                                        enum: ['containerization', 'database', 'web-server', 'cache', 'message-queue', 'monitoring', 'security', 'ci-cd', 'infrastructure']
+                                        enum: [
+                                            'containerization',
+                                            'database',
+                                            'web-server',
+                                            'cache',
+                                            'message-queue',
+                                            'monitoring',
+                                            'security',
+                                            'ci-cd',
+                                            'infrastructure',
+                                        ],
                                     },
-                                    description: 'Filter by specific technology categories'
+                                    description: 'Filter by specific technology categories',
                                 },
                                 customRequirements: {
                                     type: 'array',
                                     items: { type: 'string' },
-                                    description: 'Additional custom requirements'
+                                    description: 'Additional custom requirements',
                                 },
                                 includeRollback: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include rollback procedures'
+                                    description: 'Include rollback procedures',
                                 },
                                 generateFiles: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Actually generate files (vs just guidance)'
-                                }
+                                    description: 'Actually generate files (vs just guidance)',
+                                },
                             },
-                            required: []
-                        }
+                            required: [],
+                        },
                     },
                     {
                         name: 'smart_git_push',
@@ -1551,11 +1729,11 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 branch: {
                                     type: 'string',
-                                    description: 'Target branch for push (optional, uses current branch if not specified)'
+                                    description: 'Target branch for push (optional, uses current branch if not specified)',
                                 },
                                 message: {
                                     type: 'string',
-                                    description: 'Commit message (optional, commits staged files if provided)'
+                                    description: 'Commit message (optional, commits staged files if provided)',
                                 },
                                 testResults: {
                                     type: 'object',
@@ -1563,36 +1741,36 @@ export class McpAdrAnalysisServer {
                                     properties: {
                                         success: {
                                             type: 'boolean',
-                                            description: 'Whether all tests passed'
+                                            description: 'Whether all tests passed',
                                         },
                                         testsRun: {
                                             type: 'number',
-                                            description: 'Total number of tests executed'
+                                            description: 'Total number of tests executed',
                                         },
                                         testsPassed: {
                                             type: 'number',
-                                            description: 'Number of tests that passed'
+                                            description: 'Number of tests that passed',
                                         },
                                         testsFailed: {
                                             type: 'number',
-                                            description: 'Number of tests that failed'
+                                            description: 'Number of tests that failed',
                                         },
                                         duration: {
                                             type: 'number',
-                                            description: 'Test execution duration in seconds'
+                                            description: 'Test execution duration in seconds',
                                         },
                                         command: {
                                             type: 'string',
-                                            description: 'Test command that was executed by AI'
+                                            description: 'Test command that was executed by AI',
                                         },
                                         output: {
                                             type: 'string',
-                                            description: 'Test execution output'
+                                            description: 'Test execution output',
                                         },
                                         failureDetails: {
                                             type: 'array',
                                             items: { type: 'string' },
-                                            description: 'Details of test failures'
+                                            description: 'Details of test failures',
                                         },
                                         testTypes: {
                                             type: 'object',
@@ -1601,34 +1779,34 @@ export class McpAdrAnalysisServer {
                                                 type: 'object',
                                                 properties: {
                                                     passed: { type: 'number' },
-                                                    failed: { type: 'number' }
-                                                }
-                                            }
-                                        }
+                                                    failed: { type: 'number' },
+                                                },
+                                            },
+                                        },
                                     },
-                                    required: ['success', 'testsRun', 'testsPassed', 'testsFailed']
+                                    required: ['success', 'testsRun', 'testsPassed', 'testsFailed'],
                                 },
                                 skipSecurity: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Skip security scanning (NOT RECOMMENDED)'
+                                    description: 'Skip security scanning (NOT RECOMMENDED)',
                                 },
                                 dryRun: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Show what would be pushed without actually pushing'
+                                    description: 'Show what would be pushed without actually pushing',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to project directory (defaults to current working directory)'
+                                    description: 'Path to project directory (defaults to current working directory)',
                                 },
                                 forceUnsafe: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Override security blocks and test failures (DANGEROUS)'
-                                }
-                            }
-                        }
+                                    description: 'Override security blocks and test failures (DANGEROUS)',
+                                },
+                            },
+                        },
                     },
                     {
                         name: 'deployment_readiness',
@@ -1638,222 +1816,267 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['check_readiness', 'validate_production', 'test_validation', 'deployment_history', 'full_audit', 'emergency_override'],
-                                    description: 'Type of deployment readiness check to perform'
+                                    enum: [
+                                        'check_readiness',
+                                        'validate_production',
+                                        'test_validation',
+                                        'deployment_history',
+                                        'full_audit',
+                                        'emergency_override',
+                                    ],
+                                    description: 'Type of deployment readiness check to perform',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to project directory (defaults to current working directory)'
+                                    description: 'Path to project directory (defaults to current working directory)',
                                 },
                                 targetEnvironment: {
                                     type: 'string',
                                     enum: ['staging', 'production', 'integration'],
                                     default: 'production',
-                                    description: 'Target deployment environment'
+                                    description: 'Target deployment environment',
                                 },
                                 strictMode: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Enable strict validation (recommended for production)'
+                                    description: 'Enable strict validation (recommended for production)',
                                 },
                                 allowMockCode: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Allow mock code in deployment (NOT RECOMMENDED)'
+                                    description: 'Allow mock code in deployment (NOT RECOMMENDED)',
                                 },
                                 productionCodeThreshold: {
                                     type: 'number',
                                     default: 85,
-                                    description: 'Minimum production code quality score (0-100)'
+                                    description: 'Minimum production code quality score (0-100)',
                                 },
                                 mockCodeMaxAllowed: {
                                     type: 'number',
                                     default: 0,
-                                    description: 'Maximum mock code indicators allowed'
+                                    description: 'Maximum mock code indicators allowed',
                                 },
                                 maxTestFailures: {
                                     type: 'number',
                                     default: 0,
-                                    description: 'Maximum test failures allowed (0 = zero tolerance)'
+                                    description: 'Maximum test failures allowed (0 = zero tolerance)',
                                 },
                                 requireTestCoverage: {
                                     type: 'number',
                                     default: 80,
-                                    description: 'Minimum test coverage percentage required'
+                                    description: 'Minimum test coverage percentage required',
                                 },
                                 blockOnFailingTests: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Block deployment if tests are failing'
+                                    description: 'Block deployment if tests are failing',
                                 },
                                 testSuiteRequired: {
                                     type: 'array',
                                     items: { type: 'string' },
                                     default: [],
-                                    description: 'Required test suites that must pass'
+                                    description: 'Required test suites that must pass',
                                 },
                                 maxRecentFailures: {
                                     type: 'number',
                                     default: 2,
-                                    description: 'Maximum recent deployment failures allowed'
+                                    description: 'Maximum recent deployment failures allowed',
                                 },
                                 deploymentSuccessThreshold: {
                                     type: 'number',
                                     default: 80,
-                                    description: 'Minimum deployment success rate required (%)'
+                                    description: 'Minimum deployment success rate required (%)',
                                 },
                                 blockOnRecentFailures: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Block if recent deployments failed'
+                                    description: 'Block if recent deployments failed',
                                 },
                                 rollbackFrequencyThreshold: {
                                     type: 'number',
                                     default: 20,
-                                    description: 'Maximum rollback frequency allowed (%)'
+                                    description: 'Maximum rollback frequency allowed (%)',
                                 },
                                 requireAdrCompliance: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Require ADR compliance validation'
+                                    description: 'Require ADR compliance validation',
                                 },
                                 integrateTodoTasks: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Auto-create blocking tasks for issues'
+                                    description: 'Auto-create blocking tasks for issues',
                                 },
                                 updateHealthScoring: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Update project health scores'
+                                    description: 'Update project health scores',
                                 },
                                 triggerSmartGitPush: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Trigger smart git push validation'
+                                    description: 'Trigger smart git push validation',
                                 },
                                 emergencyBypass: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Emergency bypass for critical fixes'
+                                    description: 'Emergency bypass for critical fixes',
                                 },
                                 businessJustification: {
                                     type: 'string',
-                                    description: 'Business justification for overrides (required for emergency_override)'
+                                    description: 'Business justification for overrides (required for emergency_override)',
                                 },
                                 approvalRequired: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Require approval for overrides'
-                                }
+                                    description: 'Require approval for overrides',
+                                },
+                                enableMemoryIntegration: {
+                                    type: 'boolean',
+                                    description: 'Enable memory entity storage for deployment assessment tracking and historical analysis',
+                                    default: true,
+                                },
+                                migrateExistingHistory: {
+                                    type: 'boolean',
+                                    description: 'Migrate existing JSON-based deployment history to memory entities',
+                                    default: true,
+                                },
                             },
-                            required: ['operation']
-                        }
+                            required: ['operation'],
+                        },
                     },
                     {
                         name: 'troubleshoot_guided_workflow',
-                        description: 'Structured failure analysis and test plan generation - provide JSON failure info to get specific test commands',
+                        description: 'Structured failure analysis and test plan generation with memory integration for troubleshooting session tracking and intelligent ADR/research suggestion capabilities - provide JSON failure info to get specific test commands',
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 operation: {
                                     type: 'string',
                                     enum: ['analyze_failure', 'generate_test_plan', 'full_workflow'],
-                                    description: 'Type of troubleshooting operation'
+                                    description: 'Type of troubleshooting operation',
                                 },
                                 failure: {
                                     type: 'object',
                                     properties: {
                                         failureType: {
                                             type: 'string',
-                                            enum: ['test_failure', 'deployment_failure', 'build_failure', 'runtime_error', 'performance_issue', 'security_issue', 'other'],
-                                            description: 'Type of failure'
+                                            enum: [
+                                                'test_failure',
+                                                'deployment_failure',
+                                                'build_failure',
+                                                'runtime_error',
+                                                'performance_issue',
+                                                'security_issue',
+                                                'other',
+                                            ],
+                                            description: 'Type of failure',
                                         },
                                         failureDetails: {
                                             type: 'object',
                                             properties: {
                                                 command: {
                                                     type: 'string',
-                                                    description: 'Command that failed (optional)'
+                                                    description: 'Command that failed (optional)',
                                                 },
                                                 exitCode: {
                                                     type: 'number',
-                                                    description: 'Exit code of failed process (optional)'
+                                                    description: 'Exit code of failed process (optional)',
                                                 },
                                                 errorMessage: {
                                                     type: 'string',
-                                                    description: 'Primary error message'
+                                                    description: 'Primary error message',
                                                 },
                                                 stackTrace: {
                                                     type: 'string',
-                                                    description: 'Stack trace if available (optional)'
+                                                    description: 'Stack trace if available (optional)',
                                                 },
                                                 logOutput: {
                                                     type: 'string',
-                                                    description: 'Relevant log output (optional)'
+                                                    description: 'Relevant log output (optional)',
                                                 },
                                                 environment: {
                                                     type: 'string',
-                                                    description: 'Environment where failure occurred (optional)'
+                                                    description: 'Environment where failure occurred (optional)',
                                                 },
                                                 timestamp: {
                                                     type: 'string',
-                                                    description: 'When the failure occurred (optional)'
+                                                    description: 'When the failure occurred (optional)',
                                                 },
                                                 affectedFiles: {
                                                     type: 'array',
                                                     items: { type: 'string' },
-                                                    description: 'Files involved in the failure (optional)'
-                                                }
+                                                    description: 'Files involved in the failure (optional)',
+                                                },
                                             },
                                             required: ['errorMessage'],
-                                            description: 'Detailed failure information'
+                                            description: 'Detailed failure information',
                                         },
                                         context: {
                                             type: 'object',
                                             properties: {
                                                 recentChanges: {
                                                     type: 'string',
-                                                    description: 'Recent changes that might be related (optional)'
+                                                    description: 'Recent changes that might be related (optional)',
                                                 },
                                                 reproducible: {
                                                     type: 'boolean',
-                                                    description: 'Whether the failure is reproducible (optional)'
+                                                    description: 'Whether the failure is reproducible (optional)',
                                                 },
                                                 frequency: {
                                                     type: 'string',
-                                                    description: 'How often this failure occurs (optional)'
+                                                    description: 'How often this failure occurs (optional)',
                                                 },
                                                 impact: {
                                                     type: 'string',
                                                     enum: ['low', 'medium', 'high', 'critical'],
-                                                    description: 'Impact level of the failure (optional)'
-                                                }
+                                                    description: 'Impact level of the failure (optional)',
+                                                },
                                             },
-                                            description: 'Additional context about the failure (optional)'
-                                        }
+                                            description: 'Additional context about the failure (optional)',
+                                        },
                                     },
                                     required: ['failureType', 'failureDetails'],
-                                    description: 'Structured failure information (required for analyze_failure and generate_test_plan)'
+                                    description: 'Structured failure information (required for analyze_failure and generate_test_plan)',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to project directory (optional)'
+                                    description: 'Path to project directory (optional)',
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     description: 'ADR directory path',
-                                    default: 'docs/adrs'
+                                    default: 'docs/adrs',
                                 },
                                 todoPath: {
                                     type: 'string',
                                     description: 'Path to TODO.md file',
-                                    default: 'TODO.md'
+                                    default: 'TODO.md',
+                                },
+                                enableMemoryIntegration: {
+                                    type: 'boolean',
+                                    description: 'Enable memory entity storage for troubleshooting session tracking and pattern recognition',
+                                    default: true,
+                                },
+                                enablePatternRecognition: {
+                                    type: 'boolean',
+                                    description: 'Enable automatic pattern recognition and failure classification',
+                                    default: true,
+                                },
+                                enableAdrSuggestion: {
+                                    type: 'boolean',
+                                    description: 'Enable automatic ADR suggestion based on recurring failures',
+                                    default: true,
+                                },
+                                enableResearchGeneration: {
+                                    type: 'boolean',
+                                    description: 'Enable automatic research question generation for persistent problems',
+                                    default: true,
                                 },
-                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA,
                             },
-                            required: ['operation']
-                        }
+                            required: ['operation'],
+                        },
                     },
                     {
                         name: 'smart_score',
@@ -1863,70 +2086,91 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['recalculate_scores', 'sync_scores', 'diagnose_scores', 'optimize_weights', 'reset_scores', 'get_score_trends', 'get_intent_scores'],
-                                    description: 'Smart scoring operation to perform'
+                                    enum: [
+                                        'recalculate_scores',
+                                        'sync_scores',
+                                        'diagnose_scores',
+                                        'optimize_weights',
+                                        'reset_scores',
+                                        'get_score_trends',
+                                        'get_intent_scores',
+                                    ],
+                                    description: 'Smart scoring operation to perform',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Path to project directory'
+                                    description: 'Path to project directory',
                                 },
                                 components: {
                                     type: 'array',
                                     items: {
                                         type: 'string',
-                                        enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all']
+                                        enum: [
+                                            'task_completion',
+                                            'deployment_readiness',
+                                            'architecture_compliance',
+                                            'security_posture',
+                                            'code_quality',
+                                            'all',
+                                        ],
                                     },
                                     default: ['all'],
-                                    description: 'Score components to recalculate (for recalculate_scores operation)'
+                                    description: 'Score components to recalculate (for recalculate_scores operation)',
                                 },
                                 forceUpdate: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Force update even if data is fresh'
+                                    description: 'Force update even if data is fresh',
                                 },
                                 updateSources: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Trigger source tool updates before recalculating'
+                                    description: 'Trigger source tool updates before recalculating',
                                 },
                                 todoPath: {
                                     type: 'string',
                                     default: 'TODO.md',
-                                    description: 'Path to TODO.md file (for sync_scores operation)'
+                                    description: 'Path to TODO.md file (for sync_scores operation)',
                                 },
                                 triggerTools: {
                                     type: 'array',
                                     items: {
                                         type: 'string',
-                                        enum: ['manage_todo_json', 'smart_git_push', 'compare_adr_progress', 'analyze_content_security', 'validate_rules']
+                                        enum: [
+                                            'manage_todo_json',
+                                            'smart_git_push',
+                                            'compare_adr_progress',
+                                            'analyze_content_security',
+                                            'validate_rules',
+                                        ],
                                     },
-                                    description: 'Tools to trigger for fresh data (for sync_scores operation)'
+                                    description: 'Tools to trigger for fresh data (for sync_scores operation)',
                                 },
                                 rebalanceWeights: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Recalculate optimal scoring weights (for sync_scores operation)'
+                                    description: 'Recalculate optimal scoring weights (for sync_scores operation)',
                                 },
                                 includeHistory: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include score history analysis (for diagnose_scores operation)'
+                                    description: 'Include score history analysis (for diagnose_scores operation)',
                                 },
                                 checkDataFreshness: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Validate data freshness across tools (for diagnose_scores operation)'
+                                    description: 'Validate data freshness across tools (for diagnose_scores operation)',
                                 },
                                 suggestImprovements: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Provide score improvement suggestions (for diagnose_scores operation)'
+                                    description: 'Provide score improvement suggestions (for diagnose_scores operation)',
                                 },
                                 analysisMode: {
                                     type: 'string',
                                     enum: ['current_state', 'historical_data', 'project_type'],
                                     default: 'current_state',
-                                    description: 'Method for weight optimization (for optimize_weights operation)'
+                                    description: 'Method for weight optimization (for optimize_weights operation)',
                                 },
                                 customWeights: {
                                     type: 'object',
@@ -1935,38 +2179,45 @@ export class McpAdrAnalysisServer {
                                         deploymentReadiness: { type: 'number', minimum: 0, maximum: 1 },
                                         architectureCompliance: { type: 'number', minimum: 0, maximum: 1 },
                                         securityPosture: { type: 'number', minimum: 0, maximum: 1 },
-                                        codeQuality: { type: 'number', minimum: 0, maximum: 1 }
+                                        codeQuality: { type: 'number', minimum: 0, maximum: 1 },
                                     },
-                                    description: 'Custom weight overrides (for optimize_weights operation)'
+                                    description: 'Custom weight overrides (for optimize_weights operation)',
                                 },
                                 previewOnly: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Preview changes without applying (for optimize_weights operation)'
+                                    description: 'Preview changes without applying (for optimize_weights operation)',
                                 },
                                 component: {
                                     type: 'string',
-                                    enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all'],
+                                    enum: [
+                                        'task_completion',
+                                        'deployment_readiness',
+                                        'architecture_compliance',
+                                        'security_posture',
+                                        'code_quality',
+                                        'all',
+                                    ],
                                     default: 'all',
-                                    description: 'Score component to reset (for reset_scores operation)'
+                                    description: 'Score component to reset (for reset_scores operation)',
                                 },
                                 preserveHistory: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Preserve score history in backup (for reset_scores operation)'
+                                    description: 'Preserve score history in backup (for reset_scores operation)',
                                 },
                                 recalculateAfterReset: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Immediately recalculate after reset (for reset_scores operation)'
+                                    description: 'Immediately recalculate after reset (for reset_scores operation)',
                                 },
                                 intentId: {
                                     type: 'string',
-                                    description: 'Intent ID to get score trends for (for get_intent_scores operation)'
-                                }
+                                    description: 'Intent ID to get score trends for (for get_intent_scores operation)',
+                                },
                             },
-                            required: ['operation', 'projectPath']
-                        }
+                            required: ['operation', 'projectPath'],
+                        },
                     },
                     {
                         name: 'mcp_planning',
@@ -1976,20 +2227,27 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['create_project', 'manage_phases', 'track_progress', 'manage_resources', 'risk_analysis', 'generate_reports'],
-                                    description: 'Project planning operation to perform'
+                                    enum: [
+                                        'create_project',
+                                        'manage_phases',
+                                        'track_progress',
+                                        'manage_resources',
+                                        'risk_analysis',
+                                        'generate_reports',
+                                    ],
+                                    description: 'Project planning operation to perform',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Project root path'
+                                    description: 'Project root path',
                                 },
                                 projectName: {
                                     type: 'string',
-                                    description: 'Project name (for create_project operation)'
+                                    description: 'Project name (for create_project operation)',
                                 },
                                 description: {
                                     type: 'string',
-                                    description: 'Project description (for create_project operation)'
+                                    description: 'Project description (for create_project operation)',
                                 },
                                 phases: {
                                     type: 'array',
@@ -2001,17 +2259,17 @@ export class McpAdrAnalysisServer {
                                             dependencies: {
                                                 type: 'array',
                                                 items: { type: 'string' },
-                                                default: []
+                                                default: [],
                                             },
                                             milestones: {
                                                 type: 'array',
                                                 items: { type: 'string' },
-                                                default: []
-                                            }
+                                                default: [],
+                                            },
                                         },
-                                        required: ['name', 'duration']
+                                        required: ['name', 'duration'],
                                     },
-                                    description: 'Initial project phases (for create_project operation)'
+                                    description: 'Initial project phases (for create_project operation)',
                                 },
                                 team: {
                                     type: 'array',
@@ -2023,33 +2281,43 @@ export class McpAdrAnalysisServer {
                                             skills: {
                                                 type: 'array',
                                                 items: { type: 'string' },
-                                                default: []
+                                                default: [],
                                             },
-                                            capacity: { type: 'string' }
+                                            capacity: { type: 'string' },
                                         },
-                                        required: ['name', 'role', 'capacity']
+                                        required: ['name', 'role', 'capacity'],
                                     },
                                     default: [],
-                                    description: 'Team structure (for create_project operation)'
+                                    description: 'Team structure (for create_project operation)',
                                 },
                                 importFromAdrs: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Import phases from existing ADRs (for create_project operation)'
+                                    description: 'Import phases from existing ADRs (for create_project operation)',
                                 },
                                 importFromTodos: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Import tasks from TODO system (for create_project operation)'
+                                    description: 'Import tasks from TODO system (for create_project operation)',
                                 },
                                 action: {
                                     type: 'string',
-                                    enum: ['list', 'create', 'update', 'delete', 'transition', 'add', 'remove', 'allocate', 'optimize'],
-                                    description: 'Management action (for manage_phases/manage_resources operations)'
+                                    enum: [
+                                        'list',
+                                        'create',
+                                        'update',
+                                        'delete',
+                                        'transition',
+                                        'add',
+                                        'remove',
+                                        'allocate',
+                                        'optimize',
+                                    ],
+                                    description: 'Management action (for manage_phases/manage_resources operations)',
                                 },
                                 phaseId: {
                                     type: 'string',
-                                    description: 'Phase ID for phase operations'
+                                    description: 'Phase ID for phase operations',
                                 },
                                 phaseData: {
                                     type: 'object',
@@ -2059,49 +2327,69 @@ export class McpAdrAnalysisServer {
                                         estimatedDuration: { type: 'string' },
                                         dependencies: {
                                             type: 'array',
-                                            items: { type: 'string' }
+                                            items: { type: 'string' },
                                         },
                                         milestones: {
                                             type: 'array',
-                                            items: { type: 'string' }
+                                            items: { type: 'string' },
                                         },
                                         linkedAdrs: {
                                             type: 'array',
-                                            items: { type: 'string' }
-                                        }
+                                            items: { type: 'string' },
+                                        },
                                     },
-                                    description: 'Phase data for create/update operations'
+                                    description: 'Phase data for create/update operations',
                                 },
                                 targetStatus: {
                                     type: 'string',
                                     enum: ['planning', 'active', 'completed', 'blocked', 'cancelled'],
-                                    description: 'Target status for phase transition'
+                                    description: 'Target status for phase transition',
                                 },
                                 reportType: {
                                     type: 'string',
-                                    enum: ['summary', 'detailed', 'gantt', 'milestones', 'risks', 'executive', 'status', 'health', 'team_performance', 'milestone_tracking'],
+                                    enum: [
+                                        'summary',
+                                        'detailed',
+                                        'gantt',
+                                        'milestones',
+                                        'risks',
+                                        'executive',
+                                        'status',
+                                        'health',
+                                        'team_performance',
+                                        'milestone_tracking',
+                                    ],
                                     default: 'summary',
-                                    description: 'Type of progress report or generated report'
+                                    description: 'Type of progress report or generated report',
                                 },
                                 timeframe: {
                                     type: 'string',
-                                    enum: ['current', 'weekly', 'monthly', 'quarterly', 'week', 'month', 'quarter', 'project'],
+                                    enum: [
+                                        'current',
+                                        'weekly',
+                                        'monthly',
+                                        'quarterly',
+                                        'week',
+                                        'month',
+                                        'quarter',
+                                        'project',
+                                    ],
                                     default: 'current',
-                                    description: 'Time frame for reports and tracking'
+                                    description: 'Time frame for reports and tracking',
                                 },
                                 includeVisuals: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include visual progress indicators'
+                                    description: 'Include visual progress indicators',
                                 },
                                 updateTaskProgress: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Sync progress from TODO system'
+                                    description: 'Sync progress from TODO system',
                                 },
                                 memberId: {
                                     type: 'string',
-                                    description: 'Team member ID for resource operations'
+                                    description: 'Team member ID for resource operations',
                                 },
                                 memberData: {
                                     type: 'object',
@@ -2110,11 +2398,11 @@ export class McpAdrAnalysisServer {
                                         role: { type: 'string' },
                                         skills: {
                                             type: 'array',
-                                            items: { type: 'string' }
+                                            items: { type: 'string' },
                                         },
-                                        capacity: { type: 'string' }
+                                        capacity: { type: 'string' },
                                     },
-                                    description: 'Team member data for resource operations'
+                                    description: 'Team member data for resource operations',
                                 },
                                 allocationData: {
                                     type: 'object',
@@ -2123,52 +2411,52 @@ export class McpAdrAnalysisServer {
                                         allocation: {
                                             type: 'number',
                                             minimum: 0,
-                                            maximum: 100
-                                        }
+                                            maximum: 100,
+                                        },
                                     },
                                     required: ['phaseId', 'allocation'],
-                                    description: 'Resource allocation data'
+                                    description: 'Resource allocation data',
                                 },
                                 analysisType: {
                                     type: 'string',
                                     enum: ['automated', 'manual', 'comprehensive'],
                                     default: 'comprehensive',
-                                    description: 'Type of risk analysis'
+                                    description: 'Type of risk analysis',
                                 },
                                 includeAdrRisks: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Analyze risks from ADR complexity'
+                                    description: 'Analyze risks from ADR complexity',
                                 },
                                 includeDependencyRisks: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Analyze dependency chain risks'
+                                    description: 'Analyze dependency chain risks',
                                 },
                                 includeResourceRisks: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Analyze resource allocation risks'
+                                    description: 'Analyze resource allocation risks',
                                 },
                                 generateMitigation: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Generate mitigation strategies'
+                                    description: 'Generate mitigation strategies',
                                 },
                                 format: {
                                     type: 'string',
                                     enum: ['markdown', 'json', 'html'],
                                     default: 'markdown',
-                                    description: 'Report output format'
+                                    description: 'Report output format',
                                 },
                                 includeCharts: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include progress charts and graphs'
-                                }
+                                    description: 'Include progress charts and graphs',
+                                },
                             },
-                            required: ['operation', 'projectPath']
-                        }
+                            required: ['operation', 'projectPath'],
+                        },
                     },
                     {
                         name: 'interactive_adr_planning',
@@ -2191,37 +2479,228 @@ export class McpAdrAnalysisServer {
                                         'update_todos',
                                         'get_guidance',
                                         'save_session',
-                                        'complete_session'
+                                        'complete_session',
                                     ],
-                                    description: 'Interactive planning operation to perform'
+                                    description: 'Interactive planning operation to perform',
                                 },
                                 sessionId: {
                                     type: 'string',
-                                    description: 'Planning session ID (required for all operations except start_session)'
+                                    description: 'Planning session ID (required for all operations except start_session)',
                                 },
                                 input: {
                                     type: 'string',
-                                    description: 'User input for the current phase (varies by phase)'
+                                    description: 'User input for the current phase (varies by phase)',
                                 },
                                 projectPath: {
                                     type: 'string',
-                                    description: 'Project root path'
+                                    description: 'Project root path',
                                 },
                                 autoResearch: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Automatically trigger research when needed'
+                                    description: 'Automatically trigger research when needed',
                                 },
                                 generateTodos: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Automatically generate TODO items from decisions'
-                                }
+                                    description: 'Automatically generate TODO items from decisions',
+                                },
                             },
-                            required: ['operation', 'projectPath']
-                        }
-                    }
-                ]
+                            required: ['operation', 'projectPath'],
+                        },
+                    },
+                    {
+                        name: 'memory_loading',
+                        description: 'Advanced memory loading tool for the memory-centric architecture. Query, explore, and manage memory entities and relationships. Load ADRs into memory system and perform intelligent queries.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                action: {
+                                    type: 'string',
+                                    enum: [
+                                        'load_adrs',
+                                        'query_entities',
+                                        'get_entity',
+                                        'find_related',
+                                        'get_intelligence',
+                                        'create_snapshot',
+                                    ],
+                                    description: 'Memory operation to perform',
+                                    default: 'query_entities',
+                                },
+                                query: {
+                                    type: 'object',
+                                    properties: {
+                                        entityTypes: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'string',
+                                                enum: [
+                                                    'architectural_decision',
+                                                    'code_component',
+                                                    'business_requirement',
+                                                    'technical_constraint',
+                                                    'quality_concern',
+                                                    'implementation_pattern',
+                                                    'environmental_factor',
+                                                    'stakeholder_input',
+                                                    'knowledge_artifact',
+                                                    'decision_context',
+                                                ],
+                                            },
+                                            description: 'Filter by entity types',
+                                        },
+                                        tags: {
+                                            type: 'array',
+                                            items: { type: 'string' },
+                                            description: 'Filter by tags',
+                                        },
+                                        textQuery: {
+                                            type: 'string',
+                                            description: 'Full-text search query',
+                                        },
+                                        relationshipTypes: {
+                                            type: 'array',
+                                            items: {
+                                                type: 'string',
+                                                enum: [
+                                                    'depends_on',
+                                                    'influences',
+                                                    'conflicts_with',
+                                                    'implements',
+                                                    'supersedes',
+                                                    'relates_to',
+                                                    'originated_from',
+                                                    'impacts',
+                                                    'constrains',
+                                                ],
+                                            },
+                                            description: 'Filter by relationship types',
+                                        },
+                                        confidenceThreshold: {
+                                            type: 'number',
+                                            minimum: 0,
+                                            maximum: 1,
+                                            description: 'Minimum confidence threshold',
+                                        },
+                                        relevanceThreshold: {
+                                            type: 'number',
+                                            minimum: 0,
+                                            maximum: 1,
+                                            description: 'Minimum relevance threshold',
+                                        },
+                                        timeRange: {
+                                            type: 'object',
+                                            properties: {
+                                                from: { type: 'string', description: 'Start date (ISO 8601)' },
+                                                to: { type: 'string', description: 'End date (ISO 8601)' },
+                                            },
+                                            description: 'Filter by time range',
+                                        },
+                                        contextFilters: {
+                                            type: 'object',
+                                            properties: {
+                                                projectPhase: { type: 'string', description: 'Project phase filter' },
+                                                businessDomain: { type: 'string', description: 'Business domain filter' },
+                                                technicalStack: {
+                                                    type: 'array',
+                                                    items: { type: 'string' },
+                                                    description: 'Technical stack filter',
+                                                },
+                                                environmentalFactors: {
+                                                    type: 'array',
+                                                    items: { type: 'string' },
+                                                    description: 'Environmental factors filter',
+                                                },
+                                            },
+                                            description: 'Context-based filters',
+                                        },
+                                        limit: {
+                                            type: 'number',
+                                            minimum: 1,
+                                            description: 'Maximum number of results',
+                                        },
+                                        sortBy: {
+                                            type: 'string',
+                                            enum: ['relevance', 'confidence', 'lastModified', 'created', 'accessCount'],
+                                            description: 'Sort field',
+                                            default: 'relevance',
+                                        },
+                                        includeRelated: {
+                                            type: 'boolean',
+                                            description: 'Include related entities and relationships',
+                                            default: false,
+                                        },
+                                        relationshipDepth: {
+                                            type: 'number',
+                                            minimum: 1,
+                                            maximum: 5,
+                                            description: 'Maximum relationship traversal depth',
+                                            default: 2,
+                                        },
+                                    },
+                                    description: 'Query parameters for entity search',
+                                },
+                                entityId: {
+                                    type: 'string',
+                                    description: 'Entity ID for get_entity and find_related actions',
+                                },
+                                maxDepth: {
+                                    type: 'number',
+                                    minimum: 1,
+                                    maximum: 5,
+                                    description: 'Maximum depth for relationship traversal (find_related action)',
+                                    default: 2,
+                                },
+                                forceReload: {
+                                    type: 'boolean',
+                                    description: 'Force reload of ADRs (load_adrs action)',
+                                    default: false,
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: 'tool_chain_orchestrator',
+                        description: 'AI-powered dynamic tool sequencing - intelligently analyze user requests and generate structured tool execution plans',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                userRequest: {
+                                    type: 'string',
+                                    description: 'User request to analyze and create tool execution plan for',
+                                },
+                                availableTools: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'List of available MCP tools to orchestrate',
+                                },
+                                executionMode: {
+                                    type: 'string',
+                                    enum: ['plan_only', 'plan_and_execute', 'validate_plan'],
+                                    description: 'Orchestration mode',
+                                    default: 'plan_only',
+                                },
+                                maxSteps: {
+                                    type: 'number',
+                                    description: 'Maximum number of steps in the execution plan',
+                                    default: 10,
+                                },
+                                allowParallel: {
+                                    type: 'boolean',
+                                    description: 'Allow parallel execution of independent steps',
+                                    default: true,
+                                },
+                                contextHints: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Additional context hints for better plan generation',
+                                },
+                            },
+                            required: ['userRequest'],
+                        },
+                    },
+                ],
             };
         });
         // Tool execution handler
@@ -2229,120 +2708,133 @@ export class McpAdrAnalysisServer {
             const { name, arguments: args } = request.params;
             try {
                 let response;
+                const safeArgs = args || {};
                 switch (name) {
                     case 'analyze_project_ecosystem':
-                        response = await this.analyzeProjectEcosystem(args);
+                        response = await this.analyzeProjectEcosystem(safeArgs);
                         break;
                     case 'get_architectural_context':
-                        response = await this.getArchitecturalContext(args);
+                        response = await this.getArchitecturalContext(safeArgs);
                         break;
                     case 'generate_adrs_from_prd':
-                        response = await this.generateAdrsFromPrd(args);
+                        response = await this.generateAdrsFromPrd(safeArgs);
                         break;
                     case 'generate_adr_todo':
-                        response = await this.generateAdrTodo(args);
+                        response = await this.generateAdrTodo(safeArgs);
                         break;
                     case 'compare_adr_progress':
-                        response = await this.compareAdrProgress(args);
+                        response = await this.compareAdrProgress(safeArgs);
                         break;
                     case 'analyze_content_security':
-                        response = await this.analyzeContentSecurity(args);
+                        response = await this.analyzeContentSecurity(safeArgs);
                         break;
                     case 'generate_content_masking':
-                        response = await this.generateContentMasking(args);
+                        response = await this.generateContentMasking(safeArgs);
                         break;
                     case 'configure_custom_patterns':
-                        response = await this.configureCustomPatterns(args);
+                        response = await this.configureCustomPatterns(safeArgs);
                         break;
                     case 'apply_basic_content_masking':
-                        response = await this.applyBasicContentMasking(args);
+                        response = await this.applyBasicContentMasking(safeArgs);
                         break;
                     case 'validate_content_masking':
-                        response = await this.validateContentMasking(args);
+                        response = await this.validateContentMasking(safeArgs);
                         break;
                     case 'manage_cache':
-                        response = await this.manageCache(args);
+                        response = await this.manageCache(safeArgs);
                         break;
                     case 'configure_output_masking':
-                        response = await this.configureOutputMasking(args);
+                        response = await this.configureOutputMasking(safeArgs);
                         break;
                     case 'suggest_adrs':
-                        response = await this.suggestAdrs(args);
+                        response = await this.suggestAdrs(safeArgs);
                         break;
                     case 'generate_adr_from_decision':
-                        response = await this.generateAdrFromDecision(args);
+                        response = await this.generateAdrFromDecision(safeArgs);
+                        break;
+                    case 'generate_adr_bootstrap':
+                        response = await this.generateAdrBootstrap(safeArgs);
                         break;
                     case 'discover_existing_adrs':
-                        response = await this.discoverExistingAdrs(args);
+                        response = await this.discoverExistingAdrs(safeArgs);
+                        break;
+                    case 'review_existing_adrs':
+                        response = await this.reviewExistingAdrs(safeArgs);
                         break;
                     case 'incorporate_research':
-                        response = await this.incorporateResearch(args);
+                        response = await this.incorporateResearch(safeArgs);
                         break;
                     case 'create_research_template':
-                        response = await this.createResearchTemplate(args);
+                        response = await this.createResearchTemplate(safeArgs);
                         break;
                     case 'request_action_confirmation':
-                        response = await this.requestActionConfirmation(args);
+                        response = await this.requestActionConfirmation(safeArgs);
                         break;
                     case 'generate_rules':
-                        response = await this.generateRules(args);
+                        response = await this.generateRules(safeArgs);
                         break;
                     case 'validate_rules':
-                        response = await this.validateRules(args);
+                        response = await this.validateRules(safeArgs);
                         break;
                     case 'create_rule_set':
-                        response = await this.createRuleSet(args);
+                        response = await this.createRuleSet(safeArgs);
                         break;
                     case 'analyze_environment':
-                        response = await this.analyzeEnvironment(args);
+                        response = await this.analyzeEnvironment(safeArgs);
                         break;
                     case 'generate_research_questions':
-                        response = await this.generateResearchQuestions(args);
+                        response = await this.generateResearchQuestions(safeArgs);
                         break;
                     case 'analyze_deployment_progress':
-                        response = await this.analyzeDeploymentProgress(args);
+                        response = await this.analyzeDeploymentProgress(safeArgs);
                         break;
                     case 'check_ai_execution_status':
-                        response = await this.checkAIExecutionStatus(args);
+                        response = await this.checkAIExecutionStatus(safeArgs);
                         break;
                     case 'get_workflow_guidance':
-                        response = await this.getWorkflowGuidance(args);
+                        response = await this.getWorkflowGuidance(safeArgs);
                         break;
                     case 'get_development_guidance':
-                        response = await this.getDevelopmentGuidance(args);
+                        response = await this.getDevelopmentGuidance(safeArgs);
                         break;
                     case 'read_file':
-                        response = await this.readFile(args);
+                        response = await this.readFile(safeArgs);
                         break;
                     case 'write_file':
-                        response = await this.writeFile(args);
+                        response = await this.writeFile(safeArgs);
                         break;
                     case 'list_directory':
-                        response = await this.listDirectory(args);
+                        response = await this.listDirectory(safeArgs);
                         break;
                     case 'manage_todo_json':
-                        response = await this.manageTodoJson(args);
+                        response = await this.manageTodoJson(safeArgs);
                         break;
                     case 'generate_deployment_guidance':
-                        response = await this.generateDeploymentGuidance(args);
+                        response = await this.generateDeploymentGuidance(safeArgs);
                         break;
                     case 'smart_git_push':
-                        response = await this.smartGitPush(args);
+                        response = await this.smartGitPush(safeArgs);
                         break;
                     case 'deployment_readiness':
-                        response = await this.deploymentReadiness(args);
+                        response = await this.deploymentReadiness(safeArgs);
                         break;
                     case 'troubleshoot_guided_workflow':
-                        response = await this.troubleshootGuidedWorkflow(args);
+                        response = await this.troubleshootGuidedWorkflow(safeArgs);
                         break;
                     case 'smart_score':
-                        response = await this.smartScore(args);
+                        response = await this.smartScore(safeArgs);
                         break;
                     case 'mcp_planning':
-                        response = await this.mcpPlanning(args);
+                        response = await this.mcpPlanning(safeArgs);
+                        break;
+                    case 'memory_loading':
+                        response = await this.memoryLoading(safeArgs);
                         break;
                     case 'interactive_adr_planning':
-                        response = await this.interactiveAdrPlanning(args);
+                        response = await this.interactiveAdrPlanning(safeArgs);
+                        break;
+                    case 'tool_chain_orchestrator':
+                        response = await this.toolChainOrchestrator(safeArgs);
                         break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
@@ -2369,21 +2861,21 @@ export class McpAdrAnalysisServer {
                         uri: 'adr://architectural_knowledge_graph',
                         name: 'Architectural Knowledge Graph',
                         description: 'Complete architectural knowledge graph of the project',
-                        mimeType: 'application/json'
+                        mimeType: 'application/json',
                     },
                     {
                         uri: 'adr://analysis_report',
                         name: 'Analysis Report',
                         description: 'Comprehensive project analysis report',
-                        mimeType: 'application/json'
+                        mimeType: 'application/json',
                     },
                     {
                         uri: 'adr://adr_list',
                         name: 'ADR List',
                         description: 'List of all Architectural Decision Records',
-                        mimeType: 'application/json'
-                    }
-                ]
+                        mimeType: 'application/json',
+                    },
+                ],
             };
         });
         // Resource reading handler
@@ -2407,8 +2899,8 @@ export class McpAdrAnalysisServer {
                 prompts: allPrompts.map(prompt => ({
                     name: prompt.name,
                     description: prompt.description,
-                    arguments: prompt.arguments
-                }))
+                    arguments: prompt.arguments,
+                })),
             };
         });
         // Prompt execution handler
@@ -2435,10 +2927,10 @@ export class McpAdrAnalysisServer {
                             role: 'user',
                             content: {
                                 type: 'text',
-                                text: renderedTemplate
-                            }
-                        }
-                    ]
+                                text: renderedTemplate,
+                            },
+                        },
+                    ],
                 };
                 return await this.applyOutputMasking(response);
             }
@@ -2469,11 +2961,13 @@ export class McpAdrAnalysisServer {
 - **Execution Mode**: ${status.executionMode}
 - **AI Model**: ${status.model}
 
-${status.reason ? `## ⚠️ Issue Detected
+${status.reason
+                            ? `## ⚠️ Issue Detected
 **Problem**: ${status.reason}
 
 ## Solution
-${!status.hasApiKey ? `
+${!status.hasApiKey
+                                ? `
 1. Get an OpenRouter API key from https://openrouter.ai/keys
 2. Add it to your MCP configuration:
    \`\`\`json
@@ -2491,7 +2985,9 @@ ${!status.hasApiKey ? `
    }
    \`\`\`
 3. Restart your MCP client (Claude Desktop, etc.)
-` : status.executionMode !== 'full' ? `
+`
+                                : status.executionMode !== 'full'
+                                    ? `
 1. Update your MCP configuration to set EXECUTION_MODE to "full":
    \`\`\`json
    {
@@ -2505,7 +3001,9 @@ ${!status.hasApiKey ? `
    }
    \`\`\`
 2. Restart your MCP client
-` : ''}` : `## ✅ Configuration Looks Good!
+`
+                                    : ''}`
+                            : `## ✅ Configuration Looks Good!
 
 AI execution is properly configured. Tools should return actual results instead of prompts.
 
@@ -2521,9 +3019,9 @@ If you're still seeing prompts instead of results, try:
 
 ## Testing
 After fixing the configuration, try calling \`suggest_adrs\` - it should return actual ADR suggestions instead of prompts.
-`
-                    }
-                ]
+`,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -2542,14 +3040,14 @@ Verify these environment variables are set in your MCP configuration:
 - OPENROUTER_API_KEY
 - EXECUTION_MODE=full
 - AI_MODEL (optional)
-`
-                    }
-                ]
+`,
+                    },
+                ],
             };
         }
     }
     async getWorkflowGuidance(args) {
-        const { goal, projectContext, availableAssets = [], timeframe = 'thorough_review', primaryConcerns = [] } = args;
+        const { goal, projectContext, availableAssets = [], timeframe = 'thorough_review', primaryConcerns = [], } = args;
         try {
             const workflowPrompt = `
 # Workflow Guidance & Tool Recommendation System
@@ -2674,7 +3172,7 @@ Make the guidance **actionable, specific, and outcome-focused** so the user can
                 systemPrompt: `You are an expert workflow advisor for the MCP ADR Analysis Server.
 Your role is to analyze user goals and project context, then recommend the optimal sequence of tools to achieve their objectives efficiently.
 Provide specific, actionable guidance with clear tool sequences, expected outcomes, and success criteria.
-Focus on practical workflows that deliver measurable results.`
+Focus on practical workflows that deliver measurable results.`,
             });
             if (executionResult.isAIGenerated) {
                 // AI execution successful - return actual workflow guidance
@@ -2720,9 +3218,9 @@ This guidance is tailored to your specific context and goals for maximum effecti
                     content: [
                         {
                             type: 'text',
-                            text: workflowPrompt
-                        }
-                    ]
+                            text: workflowPrompt,
+                        },
+                    ],
                 };
             }
         }
@@ -2731,7 +3229,7 @@ This guidance is tailored to your specific context and goals for maximum effecti
         }
     }
     async getDevelopmentGuidance(args) {
-        const { developmentPhase, adrsToImplement = [], technologyStack = [], currentProgress = '', teamContext = { size: 'small_team', experienceLevel: 'mixed' }, timeline = '', focusAreas = [] } = args;
+        const { developmentPhase, adrsToImplement = [], technologyStack = [], currentProgress = '', teamContext = { size: 'small_team', experienceLevel: 'mixed' }, timeline = '', focusAreas = [], } = args;
         try {
             // Use actual ADR discovery if ADRs are specified
             let adrAnalysisPrompt = '';
@@ -2750,14 +3248,16 @@ This guidance is tailored to your specific context and goals for maximum effecti
 **ADR Directory**: ${absoluteAdrPath}
 **Found ${targetAdrs.length} matching ADRs**
 
-${targetAdrs.map(adr => `
+${targetAdrs
+                    .map(adr => `
 ### ${adr.title}
 - **File**: ${adr.filename}
 - **Status**: ${adr.status}
 - **Context**: ${adr.context}
 - **Decision**: ${adr.decision}
 - **Consequences**: ${adr.consequences}
-`).join('\n')}
+`)
+                    .join('\n')}
 `;
             }
             const developmentPrompt = `
@@ -2895,7 +3395,7 @@ Make the guidance **actionable, specific, and immediately implementable** so dev
 Your role is to bridge the gap between architectural planning and actual code development.
 Provide specific, actionable development guidance with clear implementation steps, code patterns, and quality criteria.
 Focus on practical guidance that ensures architectural decisions are properly implemented in code.
-Consider team context, technology stack, and development phase to provide tailored recommendations.`
+Consider team context, technology stack, and development phase to provide tailored recommendations.`,
             });
             if (executionResult.isAIGenerated) {
                 // AI execution successful - return actual development guidance
@@ -2953,9 +3453,9 @@ This guidance ensures your development work is **architecturally aligned**, **qu
                     content: [
                         {
                             type: 'text',
-                            text: developmentPrompt
-                        }
-                    ]
+                            text: developmentPrompt,
+                        },
+                    ],
                 };
             }
         }
@@ -2966,7 +3466,7 @@ This guidance ensures your development work is **architecturally aligned**, **qu
     async analyzeProjectEcosystem(args) {
         // Use configured project path if not provided in args
         const projectPath = args.projectPath || this.config.projectPath;
-        const { includePatterns, enhancedMode = true, knowledgeEnhancement = true, learningEnabled = true, technologyFocus = [], analysisDepth = 'comprehensive', includeEnvironment = true, recursiveDepth = 'comprehensive', analysisScope = []
+        const { includePatterns, enhancedMode = true, knowledgeEnhancement = true, learningEnabled = true, technologyFocus = [], analysisDepth = 'comprehensive', includeEnvironment = true, recursiveDepth = 'comprehensive', analysisScope = [],
         // conversationContext - TODO: implement context integration for ecosystem analysis
          } = args;
         this.logger.info(`Generating comprehensive ecosystem analysis for project at: ${projectPath}`);
@@ -2975,7 +3475,7 @@ This guidance ensures your development work is **architecturally aligned**, **qu
         this.logger.info(`Analysis scope: ${analysisScope.length > 0 ? analysisScope.join(', ') : 'Full ecosystem analysis'}`);
         try {
             // Import utilities dynamically to avoid circular dependencies
-            const { analyzeProjectStructure } = await import('./utils/file-system.js');
+            const { analyzeProjectStructureCompat: analyzeProjectStructure } = await import('./utils/file-system.js');
             // Import advanced prompting utilities if enhanced mode is enabled
             let generateArchitecturalKnowledge = null;
             let executeWithReflexion = null;
@@ -3002,11 +3502,11 @@ This guidance ensures your development work is **architecturally aligned**, **qu
                         technologies: technologyFocus,
                         patterns: [],
                         projectType: 'ecosystem-analysis',
-                        existingAdrs: []
+                        existingAdrs: [],
                     }, {
                         domains: this.getEcosystemAnalysisDomains(technologyFocus),
                         depth: analysisDepth === 'basic' ? 'basic' : 'intermediate',
-                        cacheEnabled: true
+                        cacheEnabled: true,
                     });
                     knowledgeContext = `
 ## Technology-Specific Knowledge Enhancement
@@ -3055,7 +3555,7 @@ ${memoryResult.prompt}
                     const environmentResult = await analyzeEnvironment({
                         projectPath,
                         adrDirectory: this.config.adrDirectory,
-                        analysisType: 'comprehensive'
+                        analysisType: 'comprehensive',
                     });
                     // Extract environment analysis content
                     if (environmentResult.content && environmentResult.content[0]) {
@@ -3085,7 +3585,7 @@ ${environmentResult.content[0].text}
                     const reflexionConfig = createToolReflexionConfig('analyze_project_ecosystem', {
                         reflectionDepth: analysisDepth === 'basic' ? 'basic' : 'detailed',
                         evaluationCriteria: ['task-success', 'accuracy', 'completeness'],
-                        learningRate: 0.7
+                        learningRate: 0.7,
                     });
                     const reflexionResult = await executeWithReflexion({
                         prompt: baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext,
@@ -3099,18 +3599,20 @@ ${environmentResult.content[0].text}
                             includeEnvironment,
                             analysisScope,
                             knowledgeEnhanced: knowledgeEnhancement,
-                            learningEnabled: true
-                        }
+                            learningEnabled: true,
+                        },
                     }, reflexionConfig);
                     enhancedAnalysisPrompt = reflexionResult.prompt;
                 }
                 catch (error) {
                     this.logger.warn('Reflexion execution failed:', error);
-                    enhancedAnalysisPrompt = baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
+                    enhancedAnalysisPrompt =
+                        baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
                 }
             }
             else {
-                enhancedAnalysisPrompt = baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
+                enhancedAnalysisPrompt =
+                    baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
             }
             // Execute the analysis with AI if enabled, otherwise return prompt
             const { executeEcosystemAnalysisPrompt, formatMCPResponse } = await import('./utils/prompt-execution.js');
@@ -3129,7 +3631,7 @@ ${environmentResult.content[0].text}
                     analysisScope,
                     includeEnvironment,
                     timestamp: new Date().toISOString(),
-                    structureData: baseProjectAnalysisPrompt.context || {}
+                    structureData: baseProjectAnalysisPrompt.context || {},
                 };
                 await this.kgManager.recordProjectStructure(projectStructureSnapshot);
                 this.logger.info('✅ Project structure recorded to knowledge graph');
@@ -3167,7 +3669,8 @@ ${reflexionContext}
 
 ${executionResult.content}
 
-${includeEnvironment ? `
+${includeEnvironment
+                        ? `
 
 ## Environment Integration Summary
 
@@ -3178,7 +3681,8 @@ The analysis above includes comprehensive environment analysis covering:
 - **Compliance Assessment**: Security and regulatory compliance evaluation
 
 This integrated approach provides complete understanding of both codebase patterns AND operational environment.
-` : ''}
+`
+                        : ''}
 
 ## Next Steps: Complete Ecosystem Understanding
 
@@ -3242,19 +3746,23 @@ ${baseProjectAnalysisPrompt.instructions}
 
 ### Enhancement-Specific Instructions
 
-${enhancedMode && knowledgeEnhancement ? `
+${enhancedMode && knowledgeEnhancement
+                                ? `
 #### Knowledge Enhancement
 - Apply technology-specific knowledge to ecosystem analysis
 - Use domain expertise to identify patterns and anti-patterns
 - Leverage architectural best practices for technology stack evaluation
-` : ''}
+`
+                                : ''}
 
-${enhancedMode && learningEnabled ? `
+${enhancedMode && learningEnabled
+                                ? `
 #### Learning Integration
 - Apply lessons learned from past ecosystem analyses
 - Use memory insights to improve pattern recognition accuracy
 - Incorporate feedback from previous analysis outcomes
-` : ''}
+`
+                                : ''}
 
 ## Expected Enhanced Output
 
@@ -3270,9 +3778,9 @@ The enhanced analysis should provide:
 - Ensure analysis leverages all available enhancement features
 - Verify technology-specific knowledge is properly applied
 - Confirm learning insights improve analysis accuracy
-- Validate recommendations align with domain best practices`
-                        }
-                    ]
+- Validate recommendations align with domain best practices`,
+                        },
+                    ],
                 };
             }
         }
@@ -3283,10 +3791,12 @@ The enhanced analysis should provide:
     async getArchitecturalContext(args) {
         const { filePath, includeCompliance = true } = args;
         try {
-            const { analyzeProjectStructure, fileExists, ensureDirectory } = await import('./utils/file-system.js');
+            const { analyzeProjectStructureCompat: analyzeProjectStructure, fileExistsCompat: fileExists, ensureDirectoryCompat: ensureDirectory, } = await import('./utils/file-system.js');
             const path = await import('path');
             // Determine project path
-            const projectPath = filePath ? filePath.split('/').slice(0, -1).join('/') : this.config.projectPath;
+            const projectPath = filePath
+                ? filePath.split('/').slice(0, -1).join('/')
+                : this.config.projectPath;
             const adrDirectory = path.join(projectPath, this.config.adrDirectory);
             // Generate prompts for ADR directory setup
             const adrDirectoryCheckPrompt = await fileExists(adrDirectory);
@@ -3345,12 +3855,14 @@ ${filePath ? `- **File-specific Context**: How ${filePath} fits into the overall
 - **Technology Rationale**: Understand selection criteria and trade-offs
 - **Evolution Path**: How the architecture has changed over time
 
-${includeCompliance ? `### 5. Compliance & Standards Assessment
+${includeCompliance
+                ? `### 5. Compliance & Standards Assessment
 - **Industry Standards**: Adherence to relevant industry standards and best practices
 - **Security Compliance**: Security standards compliance (OWASP, SOC2, etc.)
 - **Code Standards**: Coding standards and style guide compliance
 - **Architectural Compliance**: Adherence to established architectural principles
-- **Regulatory Requirements**: Any regulatory compliance requirements (GDPR, HIPAA, etc.)` : ''}
+- **Regulatory Requirements**: Any regulatory compliance requirements (GDPR, HIPAA, etc.)`
+                : ''}
 
 ## Expected Output: Outcome-Focused Architectural Context
 
@@ -3451,7 +3963,7 @@ This approach ensures that architectural work is **grounded in measurable outcom
                 maxTokens: 5000,
                 systemPrompt: `You are a senior software architect specializing in architectural context analysis.
 Analyze the provided project to understand its architectural patterns, design decisions, and structural organization.
-Focus on providing actionable insights about the architecture that can guide development decisions.`
+Focus on providing actionable insights about the architecture that can guide development decisions.`,
             });
             if (executionResult.isAIGenerated) {
                 // AI execution successful - return actual analysis results
@@ -3507,9 +4019,9 @@ This **outcome-focused approach** ensures architectural work delivers **measurab
                     content: [
                         {
                             type: 'text',
-                            text: architecturalPrompt
-                        }
-                    ]
+                            text: architecturalPrompt,
+                        },
+                    ],
                 };
             }
         }
@@ -3518,12 +4030,12 @@ This **outcome-focused approach** ensures architectural work delivers **measurab
         }
     }
     async generateAdrsFromPrd(args) {
-        const { prdPath, enhancedMode = true, promptOptimization = true, knowledgeEnhancement = true, prdType = 'general' } = args;
-        const outputDirectory = args.outputDirectory || this.config.adrDirectory;
+        const { prdPath, enhancedMode = true, promptOptimization = true, knowledgeEnhancement = true, prdType = 'general', } = args;
+        const outputDirectory = args['outputDirectory'] || this.config.adrDirectory;
         this.logger.info(`Generating enhanced ADRs from PRD: ${prdPath} to ${outputDirectory}`);
         this.logger.info(`Enhancement features - APE: ${promptOptimization}, Knowledge: ${knowledgeEnhancement}, Type: ${prdType}`);
         try {
-            const { readFileContent, fileExists } = await import('./utils/file-system.js');
+            const { readFileContentCompat: readFileContent, fileExistsCompat: fileExists } = await import('./utils/file-system.js');
             // Import advanced prompting utilities if enhanced mode is enabled
             let generateArchitecturalKnowledge = null;
             let optimizePromptWithAPE = null;
@@ -3552,11 +4064,11 @@ This **outcome-focused approach** ensures architectural work delivers **measurab
                         technologies: [],
                         patterns: [],
                         projectType: prdType,
-                        existingAdrs: []
+                        existingAdrs: [],
                     }, {
                         domains: this.getPrdTypeDomains(prdType),
                         depth: 'intermediate',
-                        cacheEnabled: true
+                        cacheEnabled: true,
                     });
                     knowledgeContext = `
 ## Domain-Specific Knowledge Enhancement
@@ -3583,12 +4095,17 @@ ${knowledgeResult.prompt}
                         candidateCount: 5,
                         evaluationCriteria: ['task-completion', 'clarity', 'specificity'],
                         optimizationRounds: 2,
-                        qualityThreshold: 0.75
+                        qualityThreshold: 0.75,
                     });
                     const apeResult = await optimizePromptWithAPE({
                         prompt: baseAdrPrompt,
                         instructions: 'Generate comprehensive ADRs from PRD analysis',
-                        context: { prdPath, outputDirectory, prdType, knowledgeEnhanced: knowledgeEnhancement }
+                        context: {
+                            prdPath,
+                            outputDirectory,
+                            prdType,
+                            knowledgeEnhanced: knowledgeEnhancement,
+                        },
                     }, apeConfig);
                     finalAdrPrompt = apeResult.prompt;
                 }
@@ -3621,12 +4138,14 @@ ${fileContentPrompt.prompt}
 
 ## Step 3: Enhanced ADR Generation
 
-${enhancedMode && promptOptimization ? `
+${enhancedMode && promptOptimization
+                ? `
 ### APE-Optimized Analysis
 This prompt has been optimized using Automatic Prompt Engineering for superior ADR generation quality.
 The optimization focused on task completion, clarity, and specificity for PRD analysis.
 
-` : ''}
+`
+                : ''}
 
 ${finalAdrPrompt}
 
@@ -3653,7 +4172,7 @@ For each generated ADR, create a file creation prompt using the following patter
                 maxTokens: 8000,
                 systemPrompt: `You are an expert software architect who creates comprehensive Architectural Decision Records (ADRs) from Product Requirements Documents (PRDs).
 Generate well-structured ADRs that follow best practices and include all necessary sections.
-Focus on extracting architectural decisions from the PRD and creating actionable ADRs with clear reasoning.`
+Focus on extracting architectural decisions from the PRD and creating actionable ADRs with clear reasoning.`,
             });
             if (executionResult.isAIGenerated) {
                 // AI execution successful - return actual ADR generation results
@@ -3734,19 +4253,23 @@ ${adrPrompt}
 
 ## Advanced Features
 
-${enhancedMode && knowledgeEnhancement ? `
+${enhancedMode && knowledgeEnhancement
+                                ? `
 ### Knowledge Enhancement
 - Domain-specific architectural knowledge has been generated
 - PRD analysis is enhanced with ${prdType} domain expertise
 - ADR decisions leverage domain best practices and patterns
-` : ''}
+`
+                                : ''}
 
-${enhancedMode && promptOptimization ? `
+${enhancedMode && promptOptimization
+                                ? `
 ### APE Optimization
 - Prompts have been automatically optimized for quality
 - Enhanced evaluation criteria ensure superior ADR generation
 - Optimization focused on task completion, clarity, and specificity
-` : ''}
+`
+                                : ''}
 
 ## Security and Validation
 
@@ -3766,9 +4289,9 @@ ${enhancedMode && promptOptimization ? `
 6. Create file creation prompts for each enhanced ADR
 7. Confirm with user before writing files to: ${outputDirectory}
 
-The enhanced process maintains full traceability from PRD requirements to generated ADRs while providing superior quality through advanced prompting techniques and ensuring security and user control over file operations.`
-                        }
-                    ]
+The enhanced process maintains full traceability from PRD requirements to generated ADRs while providing superior quality through advanced prompting techniques and ensuring security and user control over file operations.`,
+                        },
+                    ],
                 };
             }
         }
@@ -3777,53 +4300,53 @@ The enhanced process maintains full traceability from PRD requirements to genera
         }
     }
     async generateAdrTodo(args) {
-        const { scope = 'all', phase = 'both', linkAdrs = true, includeRules = true, ruleSource = 'both', preserveExisting = true, forceSyncToMarkdown = false, intentId, createJsonBackup = true } = args;
+        const { scope = 'all', phase = 'both', linkAdrs = true, includeRules = true, ruleSource = 'both', preserveExisting = true, forceSyncToMarkdown = false, intentId, createJsonBackup = true, } = args;
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
         // Use absolute ADR path relative to project
-        const absoluteAdrPath = args.adrDirectory ?
-            path.resolve(this.config.projectPath, args.adrDirectory) :
-            getAdrDirectoryPath(this.config);
+        const absoluteAdrPath = args['adrDirectory']
+            ? path.resolve(this.config.projectPath, args['adrDirectory'])
+            : getAdrDirectoryPath(this.config);
         // Keep relative path for display purposes
-        const adrDirectory = args.adrDirectory || this.config.adrDirectory;
+        const adrDirectory = args['adrDirectory'] || this.config.adrDirectory;
         this.logger.info(`Generating JSON-first TODO for ADRs in: ${absoluteAdrPath} (phase: ${phase})`);
         try {
             // Always use JSON-first TODO system
             this.logger.info('Using JSON-first TODO system for ADR task generation');
-            const { manageTodoV2 } = await import('./tools/todo-management-tool-v2.js');
+            // TODO management has been deprecated and moved to mcp-shrimp-task-manager
+            this.logger.warn('⚠️ TODO management has been deprecated - use mcp-shrimp-task-manager instead');
             // Optional: Create backup if requested and JSON exists
             if (createJsonBackup) {
                 try {
-                    await manageTodoV2({
-                        operation: 'import_from_markdown',
-                        projectPath: this.config.projectPath,
-                        mergeStrategy: 'preserve_json',
-                        backupExisting: true
-                    });
-                    this.logger.info('Created backup of existing JSON TODO data');
+                    this.logger.info('Backup feature deprecated - use mcp-shrimp-task-manager for task management');
                 }
-                catch (error) {
+                catch {
                     // Continue if backup fails - might be first time setup
                     this.logger.debug('No existing JSON data to backup');
                 }
             }
-            // Import ADR tasks into JSON system with enhanced parameters
-            const importResult = await manageTodoV2({
-                operation: 'import_adr_tasks',
-                projectPath: this.config.projectPath,
-                adrDirectory: absoluteAdrPath,
-                preserveExisting,
-                autoLinkDependencies: linkAdrs,
-                ...(intentId && { intentId })
-            });
-            // Sync JSON data to markdown with force option
-            await manageTodoV2({
-                operation: 'sync_to_markdown',
-                projectPath: this.config.projectPath,
-                force: forceSyncToMarkdown
-            });
+            // Import ADR tasks into JSON system has been deprecated
+            const importResult = {
+                content: [
+                    {
+                        type: 'text',
+                        text: `⚠️ **TODO Management Deprecated**
+
+This feature has been moved to mcp-shrimp-task-manager.
+
+**Replacement:** Use the external \`mcp-shrimp-task-manager\` for:
+- Task planning and breaking down from ADRs
+- Task tracking and status updates
+- Task dependencies and priorities
+- Task completion and verification
+
+**Migration:** The system now uses memory-centric architecture where task management is handled by external MCP servers.`,
+                    },
+                ],
+            };
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# ✅ JSON-First TODO Generated from ADRs
 
@@ -3850,7 +4373,7 @@ The enhanced process maintains full traceability from PRD requirements to genera
 ✅ **Backup Protection**: Automatic data preservation during updates
 ✅ **No Manual Setup**: All cache files auto-generated, tests can immediately validate
 
-${importResult.content[0].text}
+${importResult.content?.[0]?.text || 'TODO management feature has been deprecated'}
 
 ## Available Operations (use manage_todo_v2 tool)
 1. **View Tasks**: \`get_tasks\` operation with filtering and sorting
@@ -3870,8 +4393,9 @@ ${importResult.content[0].text}
 - **Dependencies**: ADR relationships mapped to task dependencies
 - **Validation**: Architectural rules integrated into task criteria
 
-*All TODO data is now managed in JSON format with automatic markdown sync*`
-                    }]
+*All TODO data is now managed in JSON format with automatic markdown sync*`,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -3879,19 +4403,20 @@ ${importResult.content[0].text}
         }
     }
     async compareAdrProgress(args) {
-        const { todoPath = 'TODO.md', adrDirectory = this.config.adrDirectory, projectPath = this.config.projectPath, environment = 'auto-detect', environmentConfig = {}, validationType = 'full', includeFileChecks = true, includeRuleValidation = true, deepCodeAnalysis = true, functionalValidation = true, strictMode = true, environmentValidation = true } = args;
+        const { todoPath = 'TODO.md', adrDirectory = this.config.adrDirectory, projectPath = this.config.projectPath, environment = 'auto-detect', environmentConfig = {}, validationType = 'full', includeFileChecks = true, includeRuleValidation = true, deepCodeAnalysis = true, functionalValidation = true, strictMode = true, environmentValidation = true, } = args;
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
         // Resolve paths
         const absoluteTodoPath = path.resolve(projectPath, todoPath);
-        const absoluteAdrPath = adrDirectory ?
-            path.resolve(projectPath, adrDirectory) :
-            getAdrDirectoryPath(this.config);
+        const absoluteAdrPath = adrDirectory
+            ? path.resolve(projectPath, adrDirectory)
+            : getAdrDirectoryPath(this.config);
         this.logger.info(`Comparing ADR progress: TODO(${absoluteTodoPath}) vs ADRs(${absoluteAdrPath}) vs Environment(${projectPath}) [env: ${environment}]`);
         // Environment validation and auto-detection
         let detectedEnvironment = environment;
         let finalEnvironmentConfig = { ...environmentConfig };
-        if (environmentValidation && (validationType === 'full' || validationType === 'environment-only')) {
+        if (environmentValidation &&
+            (validationType === 'full' || validationType === 'environment-only')) {
             try {
                 const envResult = await this.detectAndValidateEnvironment(projectPath, environment, environmentConfig);
                 detectedEnvironment = envResult.detectedEnvironment;
@@ -3922,7 +4447,7 @@ ${importResult.content[0].text}
                     const includeContent = deepCodeAnalysis || functionalValidation;
                     projectStructure = await scanProjectStructure(projectPath, {
                         readContent: includeContent,
-                        maxFileSize: includeContent ? 10000 : 0
+                        maxFileSize: includeContent ? 10000 : 0,
                     });
                 }
                 catch (error) {
@@ -3941,24 +4466,24 @@ ${importResult.content[0].text}
                 discoveredAdrs: discoveryResult?.adrs || [],
                 adrDirectory: absoluteAdrPath,
                 projectStructure: projectStructure || null,
-                projectPath,
-                validationType,
-                includeFileChecks,
-                includeRuleValidation,
-                deepCodeAnalysis,
-                functionalValidation,
-                strictMode,
+                projectPath: projectPath,
+                validationType: validationType,
+                includeFileChecks: includeFileChecks,
+                includeRuleValidation: includeRuleValidation,
+                deepCodeAnalysis: deepCodeAnalysis,
+                functionalValidation: functionalValidation,
+                strictMode: strictMode,
                 environment: detectedEnvironment,
                 environmentConfig: finalEnvironmentConfig,
-                environmentValidation
+                environmentValidation: environmentValidation,
             });
             return {
                 content: [
                     {
                         type: 'text',
-                        text: analysis
-                    }
-                ]
+                        text: analysis,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -3984,7 +4509,7 @@ ${importResult.content[0].text}
                     '.env.test',
                     'package.json',
                     'docker-compose.yml',
-                    'Dockerfile'
+                    'Dockerfile',
                 ];
                 const existingFiles = [];
                 for (const file of envFiles) {
@@ -4017,7 +4542,7 @@ ${importResult.content[0].text}
                             requiredFiles: ['package.json', 'README.md'],
                             requiredServices: ['monitoring', 'logging'],
                             performanceRequirements: { minUptime: 99.9 },
-                            ...finalConfig
+                            ...finalConfig,
                         };
                         break;
                     case 'staging':
@@ -4026,7 +4551,7 @@ ${importResult.content[0].text}
                             requiredFiles: ['package.json'],
                             requiredServices: ['testing', 'monitoring'],
                             performanceRequirements: { minUptime: 95 },
-                            ...finalConfig
+                            ...finalConfig,
                         };
                         break;
                     case 'testing':
@@ -4035,7 +4560,7 @@ ${importResult.content[0].text}
                             requiredFiles: ['package.json'],
                             requiredServices: ['testing'],
                             performanceRequirements: {},
-                            ...finalConfig
+                            ...finalConfig,
                         };
                         break;
                     default: // development
@@ -4044,7 +4569,7 @@ ${importResult.content[0].text}
                             requiredFiles: ['package.json'],
                             requiredServices: [],
                             performanceRequirements: {},
-                            ...finalConfig
+                            ...finalConfig,
                         };
                 }
             }
@@ -4059,7 +4584,7 @@ ${importResult.content[0].text}
      * Perform local ADR progress analysis without relying on AI execution
      */
     async performLocalAdrProgressAnalysis(params) {
-        const { todoContent, todoPath, discoveredAdrs, adrDirectory, projectStructure, projectPath, validationType, includeFileChecks, includeRuleValidation, deepCodeAnalysis, functionalValidation, strictMode, environment, environmentConfig, environmentValidation } = params;
+        const { todoContent, todoPath, discoveredAdrs, adrDirectory, projectStructure, projectPath, validationType, includeFileChecks, includeRuleValidation, deepCodeAnalysis, functionalValidation, strictMode, environment, environmentConfig, environmentValidation, } = params;
         const currentDate = new Date().toISOString().split('T')[0];
         // Parse TODO content to extract tasks
         const todoTasks = this.parseTodoTasks(todoContent);
@@ -4123,31 +4648,39 @@ ${importResult.content[0].text}
 - **Required Services**: ${environmentConfig.requiredServices?.length || 0} services
 
 ## ADR Discovery Results
-${totalAdrs > 0 ?
-            `Found ${totalAdrs} ADRs:\n${discoveredAdrs.map((adr, i) => `${i + 1}. **${adr.title}** (${adr.status}) - ${adr.filename}`).join('\n')}` :
-            'No ADRs found in the specified directory.'}
+${totalAdrs > 0
+            ? `Found ${totalAdrs} ADRs:\n${discoveredAdrs
+                .map((adr, i) => `${i + 1}. **${adr.title}** (${adr.status}) - ${adr.filename}`)
+                .join('\n')}`
+            : 'No ADRs found in the specified directory.'}
 
 ## TODO Task Analysis
-${totalTasks > 0 ?
-            `Found ${totalTasks} tasks:\n${todoTasks.map((task, i) => `${i + 1}. ${task.completed ? '✅' : '⏳'} ${task.title}`).join('\n')}` :
-            'No tasks found in TODO.md file.'}
+${totalTasks > 0
+            ? `Found ${totalTasks} tasks:\n${todoTasks
+                .map((task, i) => `${i + 1}. ${task.completed ? '✅' : '⏳'} ${task.title}`)
+                .join('\n')}`
+            : 'No tasks found in TODO.md file.'}
 
 ## Alignment Analysis
 
 ### ✅ Properly Aligned Tasks
-${adrTaskMapping.aligned.length > 0 ?
-            adrTaskMapping.aligned.map(task => `- ${task.title}: Corresponds to ADR requirements`).join('\n') :
-            '- No aligned tasks identified'}
+${adrTaskMapping.aligned.length > 0
+            ? adrTaskMapping.aligned
+                .map(task => `- ${task.title}: Corresponds to ADR requirements`)
+                .join('\n')
+            : '- No aligned tasks identified'}
 
 ### ⚠️ Misaligned Tasks
-${adrTaskMapping.misaligned.length > 0 ?
-            adrTaskMapping.misaligned.map(task => `- ${task.title}: May not fully align with ADR specifications`).join('\n') :
-            '- No misaligned tasks identified'}
+${adrTaskMapping.misaligned.length > 0
+            ? adrTaskMapping.misaligned
+                .map(task => `- ${task.title}: May not fully align with ADR specifications`)
+                .join('\n')
+            : '- No misaligned tasks identified'}
 
 ### ❌ Missing Tasks
-${adrTaskMapping.missing.length > 0 ?
-            adrTaskMapping.missing.map(gap => `- ${gap}: Required by ADRs but not in TODO`).join('\n') :
-            '- No obvious missing tasks identified'}
+${adrTaskMapping.missing.length > 0
+            ? adrTaskMapping.missing.map(gap => `- ${gap}: Required by ADRs but not in TODO`).join('\n')
+            : '- No obvious missing tasks identified'}
 
 ## Implementation Status
 
@@ -4160,19 +4693,22 @@ ${mockAnalysisResults || ''}
 ## Recommendations
 
 ### High Priority Actions
-${alignmentScore < 70 ?
-            '1. **Improve ADR-TODO Alignment**: Review TODO tasks against ADR requirements\n2. **Add Missing Tasks**: Identify and add tasks required by ADRs' :
-            '1. **Maintain Current Alignment**: Continue following ADR specifications'}
-${completedTasks < totalTasks * 0.5 ?
-            '\n3. **Accelerate Implementation**: Focus on completing pending tasks' : ''}
-${environmentValidation && environment === 'production' && alignmentScore < 90 ?
-            '\n4. **⚠️ Production Environment Warning**: Current alignment may not meet production requirements' : ''}
+${alignmentScore < 70
+            ? '1. **Improve ADR-TODO Alignment**: Review TODO tasks against ADR requirements\n2. **Add Missing Tasks**: Identify and add tasks required by ADRs'
+            : '1. **Maintain Current Alignment**: Continue following ADR specifications'}
+${completedTasks < totalTasks * 0.5
+            ? '\n3. **Accelerate Implementation**: Focus on completing pending tasks'
+            : ''}
+${environmentValidation && environment === 'production' && alignmentScore < 90
+            ? '\n4. **⚠️ Production Environment Warning**: Current alignment may not meet production requirements'
+            : ''}
 
 ### Medium Priority Actions
 1. **Review Implementation Quality**: ${strictMode ? 'Strict mode analysis above shows' : 'Consider enabling strict mode for'} detailed quality assessment
 2. **Update Documentation**: Ensure TODO.md reflects current project state
-${environmentValidation ?
-            `3. **Environment Compliance**: Ensure ${environment} environment requirements are met` : ''}
+${environmentValidation
+            ? `3. **Environment Compliance**: Ensure ${environment} environment requirements are met`
+            : ''}
 
 ### Low Priority Actions
 1. **Optimize Workflow**: Consider tools for automated ADR-TODO synchronization
@@ -4231,16 +4767,17 @@ To re-run this validation with strict mode:
                 const title = taskMatch[2];
                 tasks.push({
                     title: title.trim(),
-                    completed: checkbox.toLowerCase() === 'x'
+                    completed: checkbox.toLowerCase() === 'x',
                 });
             }
             // Also look for simple list items that might be tasks
             else if (line.match(/^\s*[-*]\s+\w+/)) {
                 const title = line.replace(/^\s*[-*]\s+/, '').trim();
-                if (title.length > 3) { // Avoid very short items
+                if (title.length > 3) {
+                    // Avoid very short items
                     tasks.push({
                         title,
-                        completed: false
+                        completed: false,
                     });
                 }
             }
@@ -4257,8 +4794,14 @@ To re-run this validation with strict mode:
         // Simple keyword matching for alignment detection
         const adrKeywords = adrs.flatMap(adr => [
             adr.title.toLowerCase(),
-            ...(adr.decision || '').toLowerCase().split(/\s+/).filter((w) => w.length > 4),
-            ...(adr.context || '').toLowerCase().split(/\s+/).filter((w) => w.length > 4)
+            ...(adr.decision || '')
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((w) => w.length > 4),
+            ...(adr.context || '')
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((w) => w.length > 4),
         ]);
         // Environment-specific keywords that should be prioritized
         const envKeywords = [];
@@ -4289,7 +4832,15 @@ To re-run this validation with strict mode:
         for (const adr of adrs) {
             if (adr.status === 'accepted' && adr.decision) {
                 const decisionWords = adr.decision.toLowerCase().split(/\s+/);
-                const implementationWords = ['implement', 'create', 'build', 'develop', 'add', 'setup', 'configure'];
+                const implementationWords = [
+                    'implement',
+                    'create',
+                    'build',
+                    'develop',
+                    'add',
+                    'setup',
+                    'configure',
+                ];
                 if (implementationWords.some(word => decisionWords.includes(word))) {
                     const hasCorrespondingTask = tasks.some(task => task.title.toLowerCase().includes(adr.title.toLowerCase().split(' ')[0]));
                     if (!hasCorrespondingTask) {
@@ -4326,12 +4877,12 @@ To re-run this validation with strict mode:
         if (!projectStructure)
             return '- Project structure not available';
         const allFiles = [
-            ...projectStructure.packageFiles || [],
-            ...projectStructure.configFiles || [],
-            ...projectStructure.buildFiles || [],
-            ...projectStructure.dockerFiles || [],
-            ...projectStructure.ciFiles || [],
-            ...projectStructure.scriptFiles || []
+            ...(projectStructure.packageFiles || []),
+            ...(projectStructure.configFiles || []),
+            ...(projectStructure.buildFiles || []),
+            ...(projectStructure.dockerFiles || []),
+            ...(projectStructure.ciFiles || []),
+            ...(projectStructure.scriptFiles || []),
         ];
         let results = '### File Existence Validation\n';
         let checkCount = 0;
@@ -4345,7 +4896,9 @@ To re-run this validation with strict mode:
                     results += `- ✅ **${task.title}**: Found related files (${mentionedFiles.map(f => f.filename).join(', ')})\n`;
                     checkCount++;
                 }
-                else if (taskLower.includes('file') || taskLower.includes('create') || taskLower.includes('implement')) {
+                else if (taskLower.includes('file') ||
+                    taskLower.includes('create') ||
+                    taskLower.includes('implement')) {
                     results += `- ⚠️ **${task.title}**: No clearly related files found\n`;
                     checkCount++;
                 }
@@ -4363,8 +4916,8 @@ To re-run this validation with strict mode:
         if (!projectStructure)
             return '';
         const codeFiles = [
-            ...projectStructure.buildFiles || [],
-            ...projectStructure.configFiles || []
+            ...(projectStructure.buildFiles || []),
+            ...(projectStructure.configFiles || []),
         ].filter(file => file.content && file.content !== '[Binary or unreadable file]');
         if (codeFiles.length === 0)
             return '';
@@ -4382,7 +4935,7 @@ To re-run this validation with strict mode:
             /return\s+null;/gi,
             /return\s+""/gi,
             /return\s+\[\]/gi,
-            /return\s+{}/gi
+            /return\s+{}/gi,
         ];
         const productionPatterns = [
             /error\s+handling/gi,
@@ -4393,18 +4946,21 @@ To re-run this validation with strict mode:
             /authorization/gi,
             /database/gi,
             /api/gi,
-            /config/gi
+            /config/gi,
         ];
-        for (const file of codeFiles.slice(0, 10)) { // Limit analysis to prevent overwhelming output
+        for (const file of codeFiles.slice(0, 10)) {
+            // Limit analysis to prevent overwhelming output
             const content = file.content;
             const fileMockCount = mockPatterns.reduce((count, pattern) => count + (content.match(pattern) || []).length, 0);
             const fileProdCount = productionPatterns.reduce((count, pattern) => count + (content.match(pattern) || []).length, 0);
             mockIndicators += fileMockCount;
             productionIndicators += fileProdCount;
             if (fileMockCount > 0 || fileProdCount > 2) {
-                const status = fileMockCount > fileProdCount ? '❌ **Mock/Stub**' :
-                    fileProdCount > fileMockCount * 2 ? '✅ **Production Ready**' :
-                        '⚠️ **Partial Implementation**';
+                const status = fileMockCount > fileProdCount
+                    ? '❌ **Mock/Stub**'
+                    : fileProdCount > fileMockCount * 2
+                        ? '✅ **Production Ready**'
+                        : '⚠️ **Partial Implementation**';
                 results += `- ${status}: ${file.filename} `;
                 if (fileMockCount > 0) {
                     results += `(${fileMockCount} mock indicators) `;
@@ -4419,8 +4975,11 @@ To re-run this validation with strict mode:
         results += `- **Mock Indicators Found**: ${mockIndicators} instances\n`;
         results += `- **Production Indicators Found**: ${productionIndicators} instances\n`;
         if (strictMode) {
-            const qualityScore = productionIndicators > mockIndicators * 2 ? 'Good' :
-                productionIndicators > mockIndicators ? 'Fair' : 'Needs Improvement';
+            const qualityScore = productionIndicators > mockIndicators * 2
+                ? 'Good'
+                : productionIndicators > mockIndicators
+                    ? 'Fair'
+                    : 'Needs Improvement';
             results += `- **Quality Assessment**: ${qualityScore}\n`;
             if (mockIndicators > 0) {
                 results += `- **⚠️ Strict Mode Warning**: Found ${mockIndicators} potential mock/stub indicators\n`;
@@ -4438,12 +4997,12 @@ To re-run this validation with strict mode:
         // Check required files
         if (environmentConfig.requiredFiles) {
             const allFiles = [
-                ...projectStructure.packageFiles || [],
-                ...projectStructure.configFiles || [],
-                ...projectStructure.buildFiles || [],
-                ...projectStructure.dockerFiles || [],
-                ...projectStructure.ciFiles || [],
-                ...projectStructure.scriptFiles || []
+                ...(projectStructure.packageFiles || []),
+                ...(projectStructure.configFiles || []),
+                ...(projectStructure.buildFiles || []),
+                ...(projectStructure.dockerFiles || []),
+                ...(projectStructure.ciFiles || []),
+                ...(projectStructure.scriptFiles || []),
             ];
             const existingFiles = allFiles.map(f => f.filename);
             const missingFiles = environmentConfig.requiredFiles.filter((file) => !existingFiles.includes(file));
@@ -4472,12 +5031,12 @@ To re-run this validation with strict mode:
         if (environmentConfig.requiredFiles) {
             results += `#### Required Files for ${environment} Environment\n`;
             const allFiles = [
-                ...projectStructure.packageFiles || [],
-                ...projectStructure.configFiles || [],
-                ...projectStructure.buildFiles || [],
-                ...projectStructure.dockerFiles || [],
-                ...projectStructure.ciFiles || [],
-                ...projectStructure.scriptFiles || []
+                ...(projectStructure.packageFiles || []),
+                ...(projectStructure.configFiles || []),
+                ...(projectStructure.buildFiles || []),
+                ...(projectStructure.dockerFiles || []),
+                ...(projectStructure.ciFiles || []),
+                ...(projectStructure.scriptFiles || []),
             ];
             const existingFiles = allFiles.map(f => f.filename);
             for (const requiredFile of environmentConfig.requiredFiles) {
@@ -4495,11 +5054,13 @@ To re-run this validation with strict mode:
         results += `\n#### ${environment} Environment Recommendations\n`;
         switch (environment) {
             case 'production':
-                results += '- ⚠️ **Production Critical**: Ensure monitoring, logging, and backup strategies are implemented\n';
+                results +=
+                    '- ⚠️ **Production Critical**: Ensure monitoring, logging, and backup strategies are implemented\n';
                 results += '- 🔒 **Security**: Implement comprehensive security measures\n';
                 results += '- 📊 **Performance**: Monitor and optimize for production workloads\n';
                 if (strictMode) {
-                    results += '- 🔍 **Strict Mode**: Enhanced validation enabled for production environment\n';
+                    results +=
+                        '- 🔍 **Strict Mode**: Enhanced validation enabled for production environment\n';
                 }
                 break;
             case 'staging':
@@ -4519,8 +5080,8 @@ To re-run this validation with strict mode:
     analyzeSecurityCompliance(projectStructure, securityLevel) {
         let results = '';
         const securityFiles = [
-            ...projectStructure.configFiles || [],
-            ...projectStructure.dockerFiles || []
+            ...(projectStructure.configFiles || []),
+            ...(projectStructure.dockerFiles || []),
         ].filter(file => file.filename.includes('security') ||
             file.filename.includes('auth') ||
             file.filename.includes('.env') ||
@@ -4592,9 +5153,9 @@ ${clearPrompt.instructions}
 
 ## Expected Result
 
-After successful execution, all cache entries will be removed while preserving the cache directory structure and metadata.json file.`
-                            }
-                        ]
+After successful execution, all cache entries will be removed while preserving the cache directory structure and metadata.json file.`,
+                            },
+                        ],
                     };
                 }
                 case 'stats': {
@@ -4635,9 +5196,9 @@ The AI agent will provide:
 Use \`manage_cache\` tool with different actions:
 - \`clear\`: Remove all cache entries
 - \`cleanup\`: Remove expired entries only
-- \`invalidate\`: Remove specific cache entry`
-                            }
-                        ]
+- \`invalidate\`: Remove specific cache entry`,
+                            },
+                        ],
                     };
                 }
                 case 'cleanup': {
@@ -4660,9 +5221,9 @@ ${cleanupPrompt.instructions}
 
 ## Expected Result
 
-The AI agent will remove expired cache entries and provide a count of cleaned files.`
-                            }
-                        ]
+The AI agent will remove expired cache entries and provide a count of cleaned files.`,
+                            },
+                        ],
                     };
                 }
                 case 'invalidate': {
@@ -4690,9 +5251,9 @@ ${invalidatePrompt.instructions}
 
 **Cache Key**: ${key}
 
-The AI agent will safely remove the specified cache entry.`
-                            }
-                        ]
+The AI agent will safely remove the specified cache entry.`,
+                            },
+                        ],
                     };
                 }
                 default:
@@ -4734,9 +5295,9 @@ Use \`configure_output_masking\` tool with:
 
 ## Current Status
 ${this.maskingConfig.enabled ? '✅ Output masking is ACTIVE' : '⚠️ Output masking is DISABLED'}
-`
-                            }
-                        ]
+`,
+                            },
+                        ],
                     };
                 }
                 case 'set': {
@@ -4744,7 +5305,8 @@ ${this.maskingConfig.enabled ? '✅ Output masking is ACTIVE' : '⚠️ Output m
                     if (typeof enabled === 'boolean') {
                         newConfig.enabled = enabled;
                     }
-                    if (strategy && ['full', 'partial', 'placeholder', 'environment'].includes(strategy)) {
+                    if (strategy &&
+                        ['full', 'partial', 'placeholder', 'environment'].includes(strategy)) {
                         newConfig.strategy = strategy;
                     }
                     if (Array.isArray(customPatterns)) {
@@ -4766,12 +5328,12 @@ ${this.maskingConfig.enabled ? '✅ Output masking is ACTIVE' : '⚠️ Output m
 - **Strategy**: ${newConfig.strategy}
 - **Custom Patterns**: ${newConfig.customPatterns?.length || 0} patterns
 
-${newConfig.enabled ?
-                                    '🔒 All MCP tool and resource outputs will now be masked according to the new configuration.' :
-                                    '⚠️ Output masking is disabled. Sensitive information may be exposed in responses.'}
-`
-                            }
-                        ]
+${newConfig.enabled
+                                    ? '🔒 All MCP tool and resource outputs will now be masked according to the new configuration.'
+                                    : '⚠️ Output masking is disabled. Sensitive information may be exposed in responses.'}
+`,
+                            },
+                        ],
                     };
                 }
                 case 'reset': {
@@ -4790,9 +5352,9 @@ ${newConfig.enabled ?
 - **Skip Patterns**: ${this.maskingConfig.skipPatterns?.length || 0} patterns
 
 🔒 Default masking is now active for all outputs.
-`
-                            }
-                        ]
+`,
+                            },
+                        ],
                     };
                 }
                 default:
@@ -4810,12 +5372,17 @@ ${newConfig.enabled ?
         const domainMap = {
             'web-application': ['api-design', 'frontend-architecture', 'database-design', 'security'],
             'mobile-app': ['mobile-architecture', 'api-design', 'performance-optimization', 'security'],
-            'microservices': ['microservices', 'api-design', 'distributed-systems', 'database-design'],
-            'data-platform': ['database-design', 'data-architecture', 'performance-optimization', 'scalability'],
+            microservices: ['microservices', 'api-design', 'distributed-systems', 'database-design'],
+            'data-platform': [
+                'database-design',
+                'data-architecture',
+                'performance-optimization',
+                'scalability',
+            ],
             'api-service': ['api-design', 'microservices', 'security', 'performance-optimization'],
-            'general': ['api-design', 'database-design', 'security']
+            general: ['api-design', 'database-design', 'security'],
         };
-        return domainMap[prdType] || domainMap['general'] || ['api-design', 'database-design', 'security'];
+        return (domainMap[prdType] || domainMap['general'] || ['api-design', 'database-design', 'security']);
     }
     /**
      * Helper method to get domains for ecosystem analysis based on technology focus
@@ -4825,35 +5392,35 @@ ${newConfig.enabled ?
         const baseDomains = ['api-design', 'database-design', 'security', 'performance-optimization'];
         // Technology-specific domain mapping
         const technologyDomainMap = {
-            'react': ['frontend-architecture', 'web-applications'],
-            'vue': ['frontend-architecture', 'web-applications'],
-            'angular': ['frontend-architecture', 'web-applications'],
-            'node': ['api-design', 'microservices'],
-            'express': ['api-design', 'web-applications'],
-            'fastify': ['api-design', 'performance-optimization'],
-            'nestjs': ['api-design', 'microservices'],
-            'spring': ['api-design', 'microservices'],
-            'django': ['api-design', 'web-applications'],
-            'flask': ['api-design', 'web-applications'],
-            'rails': ['api-design', 'web-applications'],
-            'laravel': ['api-design', 'web-applications'],
-            'docker': ['containerization', 'microservices'],
-            'kubernetes': ['containerization', 'distributed-systems'],
-            'mongodb': ['database-design', 'data-architecture'],
-            'postgresql': ['database-design', 'data-architecture'],
-            'mysql': ['database-design', 'data-architecture'],
-            'redis': ['database-design', 'performance-optimization'],
-            'elasticsearch': ['database-design', 'data-architecture'],
-            'kafka': ['distributed-systems', 'data-architecture'],
-            'rabbitmq': ['distributed-systems', 'microservices'],
-            'aws': ['cloud-architecture', 'scalability'],
-            'azure': ['cloud-architecture', 'scalability'],
-            'gcp': ['cloud-architecture', 'scalability'],
-            'terraform': ['infrastructure-as-code', 'cloud-architecture'],
-            'ansible': ['infrastructure-as-code', 'automation'],
-            'jenkins': ['ci-cd', 'automation'],
+            react: ['frontend-architecture', 'web-applications'],
+            vue: ['frontend-architecture', 'web-applications'],
+            angular: ['frontend-architecture', 'web-applications'],
+            node: ['api-design', 'microservices'],
+            express: ['api-design', 'web-applications'],
+            fastify: ['api-design', 'performance-optimization'],
+            nestjs: ['api-design', 'microservices'],
+            spring: ['api-design', 'microservices'],
+            django: ['api-design', 'web-applications'],
+            flask: ['api-design', 'web-applications'],
+            rails: ['api-design', 'web-applications'],
+            laravel: ['api-design', 'web-applications'],
+            docker: ['containerization', 'microservices'],
+            kubernetes: ['containerization', 'distributed-systems'],
+            mongodb: ['database-design', 'data-architecture'],
+            postgresql: ['database-design', 'data-architecture'],
+            mysql: ['database-design', 'data-architecture'],
+            redis: ['database-design', 'performance-optimization'],
+            elasticsearch: ['database-design', 'data-architecture'],
+            kafka: ['distributed-systems', 'data-architecture'],
+            rabbitmq: ['distributed-systems', 'microservices'],
+            aws: ['cloud-architecture', 'scalability'],
+            azure: ['cloud-architecture', 'scalability'],
+            gcp: ['cloud-architecture', 'scalability'],
+            terraform: ['infrastructure-as-code', 'cloud-architecture'],
+            ansible: ['infrastructure-as-code', 'automation'],
+            jenkins: ['ci-cd', 'automation'],
             'github-actions': ['ci-cd', 'automation'],
-            'gitlab-ci': ['ci-cd', 'automation']
+            'gitlab-ci': ['ci-cd', 'automation'],
         };
         // Collect domains based on technology focus
         const technologyDomains = new Set();
@@ -4973,10 +5540,18 @@ Please provide:
         const { generateAdrFromDecision } = await import('./tools/adr-suggestion-tool.js');
         return await generateAdrFromDecision(args);
     }
+    async generateAdrBootstrap(args) {
+        const { default: generateAdrBootstrapScripts } = await import('./tools/adr-bootstrap-validation-tool.js');
+        return await generateAdrBootstrapScripts(args);
+    }
     async discoverExistingAdrs(args) {
         const { discoverExistingAdrs } = await import('./tools/adr-suggestion-tool.js');
         return await discoverExistingAdrs(args);
     }
+    async reviewExistingAdrs(args) {
+        const { reviewExistingAdrs } = await import('./tools/review-existing-adrs-tool.js');
+        return await reviewExistingAdrs(args);
+    }
     /**
      * Research integration tool implementations
      */
@@ -5031,6 +5606,129 @@ Please provide:
     /**
      * Apply content masking to MCP response
      */
+    /**
+     * Track memory operations performed by tools
+     */
+    async trackMemoryOperations(toolName, parameters, result, success) {
+        try {
+            // Check if memory integration was enabled and used
+            if (parameters?.enableMemoryIntegration === false) {
+                return; // Memory integration was explicitly disabled
+            }
+            // Extract memory operation information from result
+            const memoryOps = this.extractMemoryOperations(toolName, parameters, result);
+            if (memoryOps.length > 0) {
+                // Store memory operation tracking in knowledge graph
+                for (const op of memoryOps) {
+                    await this.kgManager.addMemoryExecution(toolName, op.action, op.entityType, success && op.success, op.details);
+                }
+            }
+        }
+        catch (error) {
+            // Don't let memory tracking errors break execution
+            console.error('[WARN] Memory operation tracking failed:', error);
+        }
+    }
+    /**
+     * Extract memory operation details from tool execution
+     */
+    extractMemoryOperations(toolName, parameters, result) {
+        const operations = [];
+        // Define memory-enabled tools and their expected operations
+        const memoryEnabledTools = {
+            analyze_content_security: {
+                entityType: 'security_pattern',
+                actions: ['store_pattern', 'analyze_institutional_security', 'track_evolution'],
+            },
+            analyze_environment: {
+                entityType: 'environment_snapshot',
+                actions: ['store_snapshot', 'analyze_trends', 'compare_configurations'],
+            },
+            deployment_readiness: {
+                entityType: 'deployment_assessment',
+                actions: ['store_assessment', 'migrate_history', 'analyze_patterns'],
+            },
+            troubleshoot_guided_workflow: {
+                entityType: 'troubleshooting_session',
+                actions: ['store_session', 'pattern_recognition', 'suggest_adrs', 'generate_research'],
+            },
+        };
+        // Check if this tool supports memory operations
+        const toolConfig = memoryEnabledTools[toolName];
+        if (!toolConfig) {
+            return operations; // Tool doesn't support memory operations
+        }
+        // Extract memory operation details from result
+        if (result?.memoryIntegration) {
+            const memoryInfo = result.memoryIntegration;
+            // Pattern entity storage operation
+            if (memoryInfo.entityStored || memoryInfo.patternStored) {
+                operations.push({
+                    action: 'entity_storage',
+                    entityType: toolConfig.entityType,
+                    success: memoryInfo.storageSuccess !== false,
+                    details: {
+                        entityId: memoryInfo.entityId || memoryInfo.patternId,
+                        entityCount: memoryInfo.entityCount || 1,
+                        storageMethod: memoryInfo.storageMethod || 'standard',
+                    },
+                });
+            }
+            // Historical analysis operation
+            if (memoryInfo.historicalAnalysis || memoryInfo.trendAnalysis) {
+                operations.push({
+                    action: 'historical_analysis',
+                    entityType: toolConfig.entityType,
+                    success: memoryInfo.analysisSuccess !== false,
+                    details: {
+                        analysisType: memoryInfo.analysisType || 'trend_analysis',
+                        entitiesAnalyzed: memoryInfo.entitiesAnalyzed || 0,
+                        insights: memoryInfo.insights || [],
+                    },
+                });
+            }
+            // Evolution tracking operation
+            if (memoryInfo.evolutionTracking) {
+                operations.push({
+                    action: 'evolution_tracking',
+                    entityType: toolConfig.entityType,
+                    success: memoryInfo.evolutionSuccess !== false,
+                    details: {
+                        improvements: memoryInfo.improvements || [],
+                        degradations: memoryInfo.degradations || [],
+                        recommendations: memoryInfo.recommendations || [],
+                    },
+                });
+            }
+            // Migration operation (for deployment readiness)
+            if (memoryInfo.migrationCompleted) {
+                operations.push({
+                    action: 'data_migration',
+                    entityType: toolConfig.entityType,
+                    success: memoryInfo.migrationSuccess !== false,
+                    details: {
+                        migratedRecords: memoryInfo.migratedRecords || 0,
+                        migrationMethod: memoryInfo.migrationMethod || 'json_to_memory',
+                    },
+                });
+            }
+        }
+        // If no specific memory integration info, infer from parameters
+        if (operations.length === 0 && parameters?.enableMemoryIntegration !== false) {
+            // Default assumption: entity was stored
+            operations.push({
+                action: 'entity_storage',
+                entityType: toolConfig.entityType,
+                success: true, // Assume success if no explicit info
+                details: {
+                    entityCount: 1,
+                    storageMethod: 'inferred',
+                    note: 'Memory operation inferred from tool execution',
+                },
+            });
+        }
+        return operations;
+    }
     /**
      * Track tool execution in knowledge graph
      */
@@ -5076,6 +5774,8 @@ Please provide:
                     todoTasksModified.push(...result.metadata.taskIds);
                 }
             }
+            // Track memory operations if present
+            await this.trackMemoryOperations(toolName, parameters, result, success);
             // Store execution in knowledge graph
             await this.kgManager.addToolExecution(intentId, toolName, parameters, result, success, todoTasksCreated, todoTasksModified, error);
             // If execution completed successfully, update intent status
@@ -5127,9 +5827,9 @@ Please provide:
                             {
                                 uri,
                                 mimeType: result.contentType,
-                                text: JSON.stringify(result.data, null, 2)
-                            }
-                        ]
+                                text: JSON.stringify(result.data, null, 2),
+                            },
+                        ],
                     };
                 }
                 case 'analysis_report': {
@@ -5143,9 +5843,9 @@ Please provide:
                             {
                                 uri,
                                 mimeType: result.contentType,
-                                text: JSON.stringify(result.data, null, 2)
-                            }
-                        ]
+                                text: JSON.stringify(result.data, null, 2),
+                            },
+                        ],
                     };
                 }
                 case 'adr_list': {
@@ -5153,9 +5853,9 @@ Please provide:
                     const { getAdrDirectoryPath } = await import('./utils/config.js');
                     const path = await import('path');
                     // Use absolute ADR path relative to project
-                    const absoluteAdrPath = params['adrDirectory'] ?
-                        path.resolve(this.config.projectPath, params['adrDirectory']) :
-                        getAdrDirectoryPath(this.config);
+                    const absoluteAdrPath = params['adrDirectory']
+                        ? path.resolve(this.config.projectPath, params['adrDirectory'])
+                        : getAdrDirectoryPath(this.config);
                     // Generate resource directly (caching is now handled through AI delegation)
                     const result = await generateAdrList(absoluteAdrPath, this.config.projectPath);
                     return {
@@ -5163,9 +5863,9 @@ Please provide:
                             {
                                 uri,
                                 mimeType: result.contentType,
-                                text: JSON.stringify(result.data, null, 2)
-                            }
-                        ]
+                                text: JSON.stringify(result.data, null, 2),
+                            },
+                        ],
                     };
                 }
                 default:
@@ -5197,7 +5897,7 @@ Please provide:
      * File system tool implementations
      */
     async readFile(args) {
-        const { path: filePath } = args;
+        const { filePath } = args;
         try {
             const fs = await import('fs/promises');
             const path = await import('path');
@@ -5212,9 +5912,9 @@ Please provide:
                 content: [
                     {
                         type: 'text',
-                        text: content
-                    }
-                ]
+                        text: content,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -5222,7 +5922,7 @@ Please provide:
         }
     }
     async writeFile(args) {
-        const { path: filePath, content } = args;
+        const { filePath, content } = args;
         try {
             const fs = await import('fs/promises');
             const path = await import('path');
@@ -5240,9 +5940,9 @@ Please provide:
                 content: [
                     {
                         type: 'text',
-                        text: `Successfully wrote to ${filePath}`
-                    }
-                ]
+                        text: `Successfully wrote to ${filePath}`,
+                    },
+                ],
             };
         }
         catch (error) {
@@ -5264,32 +5964,52 @@ Please provide:
             const fileList = entries.map(entry => ({
                 name: entry.name,
                 type: entry.isDirectory() ? 'directory' : 'file',
-                path: path.join(dirPath, entry.name)
+                path: path.join(dirPath, entry.name),
             }));
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(fileList, null, 2)
-                    }
-                ]
+                        text: JSON.stringify(fileList, null, 2),
+                    },
+                ],
             };
         }
         catch (error) {
             throw new McpAdrError(`Failed to list directory: ${error instanceof Error ? error.message : String(error)}`, 'DIRECTORY_LIST_ERROR');
         }
     }
-    async manageTodoJson(args) {
+    async manageTodoJson(_args) {
         try {
-            const { manageTodoV2 } = await import('./tools/todo-management-tool-v2.js');
-            // Add projectPath to args if not provided
-            const argsWithPath = {
-                ...args,
-                projectPath: args.projectPath || this.config.projectPath
+            // TODO management has been deprecated and moved to mcp-shrimp-task-manager
+            this.logger.warn('⚠️ manageTodoJson deprecated - use mcp-shrimp-task-manager instead');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `⚠️ **TODO Management Tool Deprecated**
+
+This tool (manageTodoJson) has been deprecated and is no longer functional.
+
+**Replacement:** Use the external \`mcp-shrimp-task-manager\` for task management:
+- Task planning and breaking down
+- Task tracking and status updates
+- Task dependencies and priorities
+- Task completion and verification
+
+**Migration:** The system has moved to a memory-centric architecture where task management is handled by external MCP servers rather than internal JSON files.
+
+**Error:** TodoJsonManager was removed - use mcp-shrimp-task-manager for task management`,
+                    },
+                ],
+                isError: false,
             };
-            return await manageTodoV2(argsWithPath);
         }
         catch (error) {
+            // If it's already a McpAdrError with good details, re-throw it as-is
+            if (error instanceof Error && error.name === 'McpAdrError') {
+                throw error;
+            }
             throw new McpAdrError(`JSON TODO management failed: ${error instanceof Error ? error.message : String(error)}`, 'TODO_JSON_MANAGEMENT_ERROR');
         }
     }
@@ -5329,14 +6049,28 @@ Please provide:
             throw new McpAdrError(`Troubleshoot guided workflow failed: ${error instanceof Error ? error.message : String(error)}`, 'TROUBLESHOOT_GUIDED_WORKFLOW_ERROR');
         }
     }
-    async smartScore(args) {
-        try {
-            const { smartScore } = await import('./tools/smart-score-tool.js');
-            return await smartScore(args);
-        }
-        catch (error) {
-            throw new McpAdrError(`Smart score analysis failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_SCORE_ERROR');
-        }
+    async smartScore(_args) {
+        // Smart score tool was removed - return deprecation message
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `⚠️ **Smart Score Tool Deprecated**
+
+This tool has been deprecated and replaced with memory-centric health scoring.
+
+**Replacement:** The new MemoryHealthScoring system tracks:
+- Memory quality and relevance
+- Retrieval performance
+- Entity relationship coherence
+- Context utilization
+- Decision alignment
+
+**Migration:** Health scoring is now integrated into the knowledge graph and automatically calculated based on memory usage patterns.`,
+                },
+            ],
+            isError: false,
+        };
     }
     async mcpPlanning(args) {
         try {
@@ -5347,6 +6081,16 @@ Please provide:
             throw new McpAdrError(`MCP planning failed: ${error instanceof Error ? error.message : String(error)}`, 'MCP_PLANNING_ERROR');
         }
     }
+    async memoryLoading(args) {
+        try {
+            const { MemoryLoadingTool } = await import('./tools/memory-loading-tool.js');
+            const memoryTool = new MemoryLoadingTool();
+            return await memoryTool.execute(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Memory loading failed: ${error instanceof Error ? error.message : String(error)}`, 'MEMORY_LOADING_ERROR');
+        }
+    }
     async interactiveAdrPlanning(args) {
         try {
             const { interactiveAdrPlanning } = await import('./tools/interactive-adr-planning-tool.js');
@@ -5356,6 +6100,18 @@ Please provide:
             throw new McpAdrError(`Interactive ADR planning failed: ${error instanceof Error ? error.message : String(error)}`, 'INTERACTIVE_ADR_PLANNING_ERROR');
         }
     }
+    /**
+     * Tool chain orchestrator implementation
+     */
+    async toolChainOrchestrator(args) {
+        try {
+            const { toolChainOrchestrator } = await import('./tools/tool-chain-orchestrator.js');
+            return await toolChainOrchestrator(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Tool chain orchestration failed: ${error instanceof Error ? error.message : String(error)}`, 'TOOL_CHAIN_ORCHESTRATOR_ERROR');
+        }
+    }
 }
 /**
  * Main execution
@@ -5416,10 +6172,11 @@ Examples:
 // Start the server if this file is run directly
 // Jest-compatible check: avoid import.meta.url which Jest cannot handle
 // Handle both direct execution and npm global package symlinks
-if (process.argv[1] && (process.argv[1].endsWith('index.js') ||
-    process.argv[1].endsWith('index.ts') ||
-    process.argv[1].endsWith('mcp-adr-analysis-server'))) {
-    main().catch((error) => {
+if (process.argv[1] &&
+    (process.argv[1].endsWith('index.js') ||
+        process.argv[1].endsWith('index.ts') ||
+        process.argv[1].endsWith('mcp-adr-analysis-server'))) {
+    main().catch(error => {
         console.error('Unhandled error:', error);
         process.exit(1);
     });