mcp-adr-analysis-server 2.0.8 → 2.0.10

package/dist/src/index.d.ts

@@ -14,6 +14,7 @@ export declare class McpAdrAnalysisServer {
     private maskingConfig;
     private config;
     private logger;
+    private kgManager;
     constructor();
     /**
      * Validate configuration and project setup
@@ -113,6 +114,10 @@ export declare class McpAdrAnalysisServer {
     /**
      * Apply content masking to MCP response
      */
+    /**
+     * Track tool execution in knowledge graph
+     */
+    private trackToolExecution;
     private applyOutputMasking;
     /**
      * Read MCP resource with prompt-driven caching
@@ -131,5 +136,8 @@ export declare class McpAdrAnalysisServer {
     private manageTodo;
     private generateDeploymentGuidance;
     private smartGitPush;
+    private troubleshootGuidedWorkflow;
+    private smartScore;
+    private humanOverride;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;GAMG;AA0EH;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAkC;;IAwBhD;;OAEG;YACW,qBAAqB;IAUnC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAKlC;;OAEG;IACH,OAAO,CAAC,aAAa;IA4hDrB;;OAEG;YACW,sBAAsB;YAgGtB,mBAAmB;YAqMnB,sBAAsB;YAmQtB,uBAAuB;YAsUvB,uBAAuB;YA0PvB,mBAAmB;YA6RnB,eAAe;YAiVf,kBAAkB;IAyFhC;;OAEG;YACW,+BAA+B;IA0K7C;;OAEG;IACH,OAAO,CAAC,cAAc;IAgCtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAkDtB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAyClC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAmFvC;;OAEG;YACW,sBAAsB;YAKtB,sBAAsB;YAKtB,uBAAuB;YAKvB,wBAAwB;YAKxB,sBAAsB;YAKtB,WAAW;YAkJX,sBAAsB;IAuHpC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAyDnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyF3B;;OAEG;YACW,WAAW;YAKX,uBAAuB;YAKvB,oBAAoB;IAKlC;;OAEG;YACW,mBAAmB;YAKnB,sBAAsB;YAKtB,yBAAyB;IAKvC;;OAEG;YACW,aAAa;YAKb,aAAa;YAKb,aAAa;IAK3B;;OAEG;YACW,kBAAkB;IAKhC;;OAEG;YACW,yBAAyB;IAKvC;;OAEG;YACW,yBAAyB;IAKvC;;OAEG;YACW,kBAAkB;IAWhC;;OAEG;YACW,YAAY;IAmF1B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B;;OAEG;YACW,QAAQ;YAiCR,SAAS;YAqCT,aAAa;YAsCb,UAAU;YAYV,0BAA0B;YAY1B,YAAY;CAW3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAEA;;;;;;GAMG;AA2EH;;GAEG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,SAAS,CAAwB;;IAyBzC;;OAEG;YACW,qBAAqB;IAUnC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAKlC;;OAEG;IACH,OAAO,CAAC,aAAa;IA0zDrB;;OAEG;YACW,sBAAsB;YAgGtB,mBAAmB;YAqMnB,sBAAsB;YAmQtB,uBAAuB;YAsUvB,uBAAuB;YA0PvB,mBAAmB;YA6RnB,eAAe;YAoZf,kBAAkB;IAyFhC;;OAEG;YACW,+BAA+B;IA0K7C;;OAEG;IACH,OAAO,CAAC,cAAc;IAgCtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAkDtB;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAyClC;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAmFvC;;OAEG;YACW,sBAAsB;YAKtB,sBAAsB;YAKtB,uBAAuB;YAKvB,wBAAwB;YAKxB,sBAAsB;YAKtB,WAAW;YAkJX,sBAAsB;IAuHpC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAyDnC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyF3B;;OAEG;YACW,WAAW;YAKX,uBAAuB;YAKvB,oBAAoB;IAKlC;;OAEG;YACW,mBAAmB;YAKnB,sBAAsB;YAKtB,yBAAyB;IAKvC;;OAEG;YACW,aAAa;YAKb,aAAa;YAKb,aAAa;IAK3B;;OAEG;YACW,kBAAkB;IAKhC;;OAEG;YACW,yBAAyB;IAKvC;;OAEG;YACW,yBAAyB;IAKvC;;OAEG;IACH;;OAEG;YACW,kBAAkB;YAkFlB,kBAAkB;IAWhC;;OAEG;YACW,YAAY;IAmF1B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B;;OAEG;YACW,QAAQ;YAiCR,SAAS;YAqCT,aAAa;YAsCb,UAAU;YAYV,0BAA0B;YAY1B,YAAY;YAYZ,0BAA0B;YAY1B,UAAU;YAYV,aAAa;CAW5B"}

package/dist/src/index.js

@@ -16,6 +16,7 @@ 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 { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
 /**
  * Get version from package.json
  */
@@ -74,10 +75,12 @@ export class McpAdrAnalysisServer {
     maskingConfig;
     config;
     logger;
+    kgManager;
     constructor() {
         // Load and validate configuration
         this.config = loadConfig();
         this.logger = createLogger(this.config);
+        this.kgManager = new KnowledgeGraphManager();
         // Print configuration summary
         printConfigSummary(this.config);
         // Note: Validation will be done during startup
@@ -275,6 +278,16 @@ export class McpAdrAnalysisServer {
                                     enum: ['adrs', 'patterns', 'both'],
                                     description: 'Source for architectural rules (only used if includeRules is true)',
                                     default: 'both'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    description: 'Path to TODO.md file (relative to project root)',
+                                    default: 'TODO.md'
+                                },
+                                preserveExisting: {
+                                    type: 'boolean',
+                                    description: 'Preserve existing TODO.md content by merging instead of overwriting',
+                                    default: true
                                 }
                             }
                         }
@@ -1029,7 +1042,8 @@ export class McpAdrAnalysisServer {
                                 },
                                 todoPath: {
                                     type: 'string',
-                                    description: 'Path to todo.md file for task identification'
+                                    description: 'Path to TODO.md file for task identification',
+                                    default: 'TODO.md'
                                 },
                                 cicdLogs: {
                                     type: 'string',
@@ -1241,12 +1255,12 @@ export class McpAdrAnalysisServer {
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['update_status', 'add_tasks', 'merge_adr_updates', 'sync_progress', 'analyze_progress'],
+                                    enum: ['update_status', 'add_tasks', 'merge_adr_updates', 'sync_progress', 'analyze_progress', 'delete_task', 'edit_task', 'move_task', 'manage_section', 'search_tasks'],
                                     description: 'Operation to perform on TODO.md'
                                 },
                                 todoPath: {
                                     type: 'string',
-                                    default: 'todo.md',
+                                    default: 'TODO.md',
                                     description: 'Path to TODO.md file'
                                 },
                                 updates: {
@@ -1445,6 +1459,266 @@ export class McpAdrAnalysisServer {
                                 }
                             }
                         }
+                    },
+                    {
+                        name: 'troubleshoot_guided_workflow',
+                        description: 'Structured failure analysis and test plan generation - 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'
+                                },
+                                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'
+                                        },
+                                        failureDetails: {
+                                            type: 'object',
+                                            properties: {
+                                                command: {
+                                                    type: 'string',
+                                                    description: 'Command that failed (optional)'
+                                                },
+                                                exitCode: {
+                                                    type: 'number',
+                                                    description: 'Exit code of failed process (optional)'
+                                                },
+                                                errorMessage: {
+                                                    type: 'string',
+                                                    description: 'Primary error message'
+                                                },
+                                                stackTrace: {
+                                                    type: 'string',
+                                                    description: 'Stack trace if available (optional)'
+                                                },
+                                                logOutput: {
+                                                    type: 'string',
+                                                    description: 'Relevant log output (optional)'
+                                                },
+                                                environment: {
+                                                    type: 'string',
+                                                    description: 'Environment where failure occurred (optional)'
+                                                },
+                                                timestamp: {
+                                                    type: 'string',
+                                                    description: 'When the failure occurred (optional)'
+                                                },
+                                                affectedFiles: {
+                                                    type: 'array',
+                                                    items: { type: 'string' },
+                                                    description: 'Files involved in the failure (optional)'
+                                                }
+                                            },
+                                            required: ['errorMessage'],
+                                            description: 'Detailed failure information'
+                                        },
+                                        context: {
+                                            type: 'object',
+                                            properties: {
+                                                recentChanges: {
+                                                    type: 'string',
+                                                    description: 'Recent changes that might be related (optional)'
+                                                },
+                                                reproducible: {
+                                                    type: 'boolean',
+                                                    description: 'Whether the failure is reproducible (optional)'
+                                                },
+                                                frequency: {
+                                                    type: 'string',
+                                                    description: 'How often this failure occurs (optional)'
+                                                },
+                                                impact: {
+                                                    type: 'string',
+                                                    enum: ['low', 'medium', 'high', 'critical'],
+                                                    description: 'Impact level of 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)'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory (optional)'
+                                },
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'ADR directory path',
+                                    default: 'docs/adrs'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    description: 'Path to TODO.md file',
+                                    default: 'TODO.md'
+                                }
+                            },
+                            required: ['operation']
+                        }
+                    },
+                    {
+                        name: 'smart_score',
+                        description: 'Central coordination for project health scoring system - recalculate, sync, diagnose, optimize, and reset scores across all MCP tools',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['recalculate_scores', 'sync_scores', 'diagnose_scores', 'optimize_weights', 'reset_scores'],
+                                    description: 'Smart scoring operation to perform'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory'
+                                },
+                                components: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'string',
+                                        enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all']
+                                    },
+                                    default: ['all'],
+                                    description: 'Score components to recalculate (for recalculate_scores operation)'
+                                },
+                                forceUpdate: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Force update even if data is fresh'
+                                },
+                                updateSources: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Trigger source tool updates before recalculating'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    default: 'TODO.md',
+                                    description: 'Path to TODO.md file (for sync_scores operation)'
+                                },
+                                triggerTools: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'string',
+                                        enum: ['manage_todo', 'smart_git_push', 'compare_adr_progress', 'analyze_content_security', 'validate_rules']
+                                    },
+                                    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)'
+                                },
+                                includeHistory: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include score history analysis (for diagnose_scores operation)'
+                                },
+                                checkDataFreshness: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Validate data freshness across tools (for diagnose_scores operation)'
+                                },
+                                suggestImprovements: {
+                                    type: 'boolean',
+                                    default: true,
+                                    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)'
+                                },
+                                customWeights: {
+                                    type: 'object',
+                                    properties: {
+                                        taskCompletion: { type: 'number', minimum: 0, maximum: 1 },
+                                        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 }
+                                    },
+                                    description: 'Custom weight overrides (for optimize_weights operation)'
+                                },
+                                previewOnly: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Preview changes without applying (for optimize_weights operation)'
+                                },
+                                component: {
+                                    type: 'string',
+                                    enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all'],
+                                    default: 'all',
+                                    description: 'Score component to reset (for reset_scores operation)'
+                                },
+                                preserveHistory: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Preserve score history in backup (for reset_scores operation)'
+                                },
+                                recalculateAfterReset: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Immediately recalculate after reset (for reset_scores operation)'
+                                }
+                            },
+                            required: ['operation', 'projectPath']
+                        }
+                    },
+                    {
+                        name: 'human_override',
+                        description: 'Human override to force AI-powered tool planning when LLMs get confused or stuck - cuts through confusion with direct task execution',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                taskDescription: {
+                                    type: 'string',
+                                    description: 'What the human wants accomplished (in plain English)'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory'
+                                },
+                                adrDirectory: {
+                                    type: 'string',
+                                    default: 'docs/adrs',
+                                    description: 'ADR directory path'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    default: 'TODO.md',
+                                    description: 'Path to TODO.md file'
+                                },
+                                priority: {
+                                    type: 'string',
+                                    enum: ['low', 'medium', 'high', 'critical'],
+                                    default: 'high',
+                                    description: 'Task priority level'
+                                },
+                                forceExecution: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Force immediate execution planning'
+                                },
+                                deadline: {
+                                    type: 'string',
+                                    description: 'When this must be completed (optional)'
+                                },
+                                additionalContext: {
+                                    type: 'string',
+                                    description: 'Any additional context or constraints (optional)'
+                                }
+                            },
+                            required: ['taskDescription', 'projectPath']
+                        }
                     }
                 ]
             };
@@ -1554,13 +1828,26 @@ export class McpAdrAnalysisServer {
                     case 'smart_git_push':
                         response = await this.smartGitPush(args);
                         break;
+                    case 'troubleshoot_guided_workflow':
+                        response = await this.troubleshootGuidedWorkflow(args);
+                        break;
+                    case 'smart_score':
+                        response = await this.smartScore(args);
+                        break;
+                    case 'human_override':
+                        response = await this.humanOverride(args);
+                        break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
                 }
                 // Apply content masking to response
+                // Track tool execution in knowledge graph
+                await this.trackToolExecution(name, args, response, true);
                 return await this.applyOutputMasking(response);
             }
             catch (error) {
+                // Track failed execution
+                await this.trackToolExecution(name, args, {}, false, error instanceof Error ? error.message : String(error));
                 if (error instanceof McpAdrError) {
                     throw error;
                 }
@@ -2960,17 +3247,72 @@ 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' } = args;
+        const { scope = 'all', phase = 'both', linkAdrs = true, includeRules = true, ruleSource = 'both', todoPath = 'todo.md', preserveExisting = true } = args;
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
+        const fs = await import('fs/promises');
         // Use absolute ADR path relative to project
         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;
+        // Resolve absolute TODO path
+        const absoluteTodoPath = path.resolve(this.config.projectPath, todoPath);
         this.logger.info(`Generating TDD-focused todo for ADRs in: ${absoluteAdrPath} (phase: ${phase})`);
         try {
+            // Check if TODO.md already exists
+            let existingTodoExists = false;
+            try {
+                await fs.access(absoluteTodoPath);
+                existingTodoExists = true;
+                this.logger.info(`Existing TODO.md found at: ${absoluteTodoPath}`);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    this.logger.error(`Error accessing existing TODO.md: ${error.message}`);
+                }
+            }
+            // If preserving existing content and file exists, use manageTodo merge instead
+            if (preserveExisting && existingTodoExists) {
+                this.logger.info('Preserving existing TODO.md content, using merge approach');
+                // Use manageTodo to merge ADR updates with existing content
+                const { manageTodo } = await import('./tools/todo-management-tool.js');
+                const mergeResult = await manageTodo({
+                    operation: 'merge_adr_updates',
+                    todoPath: absoluteTodoPath,
+                    adrDirectory: absoluteAdrPath,
+                    preserveCompleted: true,
+                    preserveCustom: true
+                }, this.config.projectPath);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# TODO.md Merge Completed
+
+## Existing File Preserved
+- **Location**: ${absoluteTodoPath}
+- **Action**: Merged ADR updates with existing content
+- **Preservation**: Custom tasks and completed items preserved
+
+## Analysis Information
+- **ADR Directory**: ${adrDirectory}
+- **Scope**: ${scope}
+- **TDD Phase**: ${phase}
+- **ADR Linking**: ${linkAdrs ? 'Enabled' : 'Disabled'}
+- **Rules Integration**: ${includeRules ? `Enabled (${ruleSource})` : 'Disabled'}
+
+${mergeResult.content[0].text}
+
+## Next Steps
+1. Review merged TODO.md content
+2. Update task statuses as needed using \`manage_todo\`
+3. Use \`compare_adr_progress\` to validate implementation status
+
+*To force regeneration, set \`preserveExisting: false\` in the request*`
+                        }]
+                };
+            }
             const { discoverAdrsInDirectory } = await import('./utils/adr-discovery.js');
             const { scanProjectStructure } = await import('./utils/actual-file-operations.js');
             // Use actual ADR discovery
@@ -4146,6 +4488,66 @@ Please provide:
     /**
      * Apply content masking to MCP response
      */
+    /**
+     * Track tool execution in knowledge graph
+     */
+    async trackToolExecution(toolName, parameters, result, success, error) {
+        try {
+            // Extract intentId from metadata if available
+            let intentId;
+            if (result?.metadata?.intentId) {
+                intentId = result.metadata.intentId;
+            }
+            else {
+                // Check for active intents that might be related to this tool execution
+                const activeIntents = await this.kgManager.getActiveIntents();
+                if (activeIntents.length > 0) {
+                    // Use the most recent active intent
+                    const latestIntent = activeIntents[activeIntents.length - 1];
+                    if (latestIntent) {
+                        intentId = latestIntent.intentId;
+                    }
+                }
+            }
+            // If no intent found, create a standalone execution record
+            if (!intentId) {
+                intentId = await this.kgManager.createIntent(`Standalone tool execution: ${toolName}`, [`Execute ${toolName}`, 'Complete tool operation'], 'medium');
+            }
+            // Determine tasks created/modified from tool operation
+            const todoTasksCreated = [];
+            const todoTasksModified = [];
+            // Extract task information from result metadata
+            if (result?.metadata) {
+                if (result.metadata.tasksCreated) {
+                    todoTasksCreated.push(...result.metadata.tasksCreated);
+                }
+                if (result.metadata.tasksModified) {
+                    todoTasksModified.push(...result.metadata.tasksModified);
+                }
+                if (result.metadata.taskIds) {
+                    todoTasksModified.push(...result.metadata.taskIds);
+                }
+            }
+            // Store execution in knowledge graph
+            await this.kgManager.addToolExecution(intentId, toolName, parameters, result, success, todoTasksCreated, todoTasksModified, error);
+            // If execution completed successfully, update intent status
+            if (success && !error) {
+                // Check if this might be the final tool in a chain
+                const intent = await this.kgManager.getIntentById(intentId);
+                if (intent && intent.currentStatus === 'executing') {
+                    // Simple heuristic: if tool is a "completion" type tool, mark intent as completed
+                    const completionTools = ['smart_git_push', 'generate_deployment_guidance', 'smart_score'];
+                    if (completionTools.includes(toolName)) {
+                        await this.kgManager.updateIntentStatus(intentId, 'completed');
+                    }
+                }
+            }
+        }
+        catch (trackingError) {
+            // Don't let tracking errors break tool execution
+            console.error('[WARN] Knowledge graph tracking failed:', trackingError);
+        }
+    }
     async applyOutputMasking(response) {
         try {
             return await maskMcpResponse(response, this.maskingConfig);
@@ -4332,7 +4734,7 @@ Please provide:
     async manageTodo(args) {
         try {
             const { manageTodo } = await import('./tools/todo-management-tool.js');
-            return await manageTodo(args);
+            return await manageTodo(args, this.config.projectPath);
         }
         catch (error) {
             throw new McpAdrError(`TODO management failed: ${error instanceof Error ? error.message : String(error)}`, 'TODO_MANAGEMENT_ERROR');
@@ -4356,6 +4758,33 @@ Please provide:
             throw new McpAdrError(`Smart git push failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_GIT_PUSH_ERROR');
         }
     }
+    async troubleshootGuidedWorkflow(args) {
+        try {
+            const { troubleshootGuidedWorkflow } = await import('./tools/troubleshoot-guided-workflow-tool.js');
+            return await troubleshootGuidedWorkflow(args);
+        }
+        catch (error) {
+            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 humanOverride(args) {
+        try {
+            const { humanOverride } = await import('./tools/human-override-tool.js');
+            return await humanOverride(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Human override failed: ${error instanceof Error ? error.message : String(error)}`, 'HUMAN_OVERRIDE_ERROR');
+        }
+    }
 }
 /**
  * Main execution