@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/tools/portfolio/submitToPortfolioTool.js

@@ -0,0 +1,1523 @@
+/**
+ * Tool for submitting content to GitHub portfolio repositories
+ * Replaces the broken issue-based submission with direct repository saves
+ *
+ * FIXES IMPLEMENTED (PR #503):
+ * 1. TYPE SAFETY FIX #1 (Issue #497): Changed apiCache from 'any' to proper APICache type
+ * 2. TYPE SAFETY FIX #2 (Issue #497): Replaced complex type casting with PortfolioElementAdapter
+ * 3. PERFORMANCE (PR #496 recommendation): Using FileDiscoveryUtil for optimized file search
+ */
+import { GitHubAuthManager } from '../../auth/GitHubAuthManager.js';
+import { PortfolioRepoManager } from '../../portfolio/PortfolioRepoManager.js';
+import { TokenManager } from '../../security/tokenManager.js';
+import { ContentValidator } from '../../security/contentValidator.js';
+import { PortfolioManager } from '../../portfolio/PortfolioManager.js';
+import { PortfolioIndexManager } from '../../portfolio/PortfolioIndexManager.js';
+import { ElementType } from '../../portfolio/types.js';
+import { logger } from '../../utils/logger.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { PortfolioElementAdapter } from './PortfolioElementAdapter.js';
+import { FileDiscoveryUtil } from '../../utils/FileDiscoveryUtil.js';
+import { ErrorHandler } from '../../utils/ErrorHandler.js';
+import { FILE_SIZE_LIMITS, RETRY_CONFIG, SEARCH_CONFIG, getValidatedTimeout, calculateRetryDelay } from '../../config/portfolio-constants.js';
+import { githubRateLimiter } from '../../utils/GitHubRateLimiter.js';
+import { EarlyTerminationSearch } from '../../utils/EarlyTerminationSearch.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+export class SubmitToPortfolioTool {
+    authManager;
+    portfolioManager;
+    contentValidator;
+    constructor(apiCache) {
+        // TYPE SAFETY FIX #1: Proper typing for apiCache parameter
+        // Previously: constructor(apiCache: any)
+        // Now: constructor(apiCache: APICache) with proper import
+        this.authManager = new GitHubAuthManager(apiCache);
+        this.portfolioManager = new PortfolioRepoManager();
+        this.contentValidator = new ContentValidator();
+    }
+    /**
+     * Validates and normalizes input parameters to prevent Unicode attacks and ensure data safety
+     * @param params The input parameters from the user
+     * @returns Validation result with normalized name or error response
+     */
+    async validateAndNormalizeParams(params) {
+        // Normalize user input to prevent Unicode attacks (DMCP-SEC-004)
+        const normalizedName = UnicodeValidator.normalize(params.name);
+        if (!normalizedName.isValid) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'UNICODE_VALIDATION_ERROR',
+                severity: 'MEDIUM',
+                source: 'SubmitToPortfolioTool.execute',
+                details: `Invalid Unicode in element name: ${normalizedName.detectedIssues?.[0] || 'unknown error'}`
+            });
+            return {
+                success: false,
+                error: {
+                    success: false,
+                    message: `Invalid characters in element name: ${normalizedName.detectedIssues?.[0] || 'unknown error'}`,
+                    error: 'INVALID_INPUT'
+                }
+            };
+        }
+        return {
+            success: true,
+            safeName: normalizedName.normalizedContent
+        };
+    }
+    /**
+     * Checks if the user is authenticated with GitHub
+     * @returns Authentication check result with status or error response
+     */
+    async checkAuthentication() {
+        const authStatus = await this.authManager.getAuthStatus();
+        if (!authStatus.isAuthenticated) {
+            // Log authentication required (using existing event type)
+            logger.warn('User attempted portfolio submission without authentication');
+            return {
+                success: false,
+                error: {
+                    success: false,
+                    message: 'Not authenticated. Please authenticate first using the GitHub OAuth flow.\n\n' +
+                        'Visit: https://docs.anthropic.com/en/docs/claude-code/oauth-setup\n' +
+                        'Or run: gh auth login --web',
+                    error: 'NOT_AUTHENTICATED'
+                }
+            };
+        }
+        return {
+            success: true,
+            authStatus
+        };
+    }
+    /**
+     * Discovers content locally with smart type detection
+     * @param safeName The normalized name to search for
+     * @param explicitType Optional explicit element type provided by user
+     * @param originalName Original user-provided name for error messages
+     * @returns Content discovery result with element type and path or error response
+     */
+    async discoverContentWithTypeDetection(safeName, explicitType, originalName) {
+        let elementType = explicitType;
+        let localPath = null;
+        if (elementType) {
+            // Type explicitly provided - search in that specific directory only
+            localPath = await this.findLocalContent(safeName, elementType);
+            if (!localPath) {
+                // UX IMPROVEMENT: Provide helpful suggestions for finding content
+                const portfolioManager = PortfolioManager.getInstance();
+                const elementDir = portfolioManager.getElementDir(elementType);
+                return {
+                    success: false,
+                    error: {
+                        success: false,
+                        message: `Could not find ${elementType} named "${originalName || safeName}" in local portfolio.\n\n` +
+                            `**Searched in**: ${elementDir}\n\n` +
+                            `**Troubleshooting Tips**:\n` +
+                            `• Check if the file exists using your file explorer\n` +
+                            `• Try using the exact filename (without extension)\n` +
+                            `• Use \`list_portfolio\` to see all available ${elementType}\n` +
+                            `• If unsure of the type, omit --type and let the system detect it\n\n` +
+                            `**Common name formats that work**:\n` +
+                            `• "my-element" (kebab-case)\n` +
+                            `• "My Element" (with spaces)\n` +
+                            `• "MyElement" (PascalCase)\n` +
+                            `• Partial matches are supported`,
+                        error: 'CONTENT_NOT_FOUND'
+                    }
+                };
+            }
+        }
+        else {
+            // CRITICAL FIX: No type provided - implement smart detection across ALL element types
+            // This prevents the previous hardcoded default to PERSONA and enables proper type detection
+            const detectionResult = await this.detectElementType(safeName);
+            if (!detectionResult.found) {
+                // UX IMPROVEMENT: Enhanced guidance with specific suggestions
+                const availableTypes = Object.values(ElementType).join(', ');
+                // Get suggestions for similar names
+                const suggestions = await this.generateNameSuggestions(safeName);
+                let message = `Content "${originalName || safeName}" not found in portfolio.\n\n`;
+                message += `🔍 **Searched in all element types**: ${availableTypes}\n\n`;
+                if (suggestions.length > 0) {
+                    message += `💡 **Did you mean one of these?**\n`;
+                    for (const suggestion of suggestions.slice(0, SEARCH_CONFIG.MAX_SUGGESTIONS)) {
+                        message += `  • "${suggestion.name}" (${suggestion.type})\n`;
+                    }
+                    message += `\n`;
+                }
+                message += `🛠️ **Troubleshooting Steps**:\n`;
+                message += `1. 📝 Use \`list_portfolio\` to see all available content\n`;
+                message += `2. 🔍 Check exact spelling and try variations:\n`;
+                message += `   • "${(originalName || safeName).toLowerCase()}" (lowercase)\n`;
+                message += `   • "${(originalName || safeName).replace(/[^a-z0-9]/gi, '-').toLowerCase()}" (normalized)\n`;
+                if ((originalName || safeName).includes('.')) {
+                    message += `   • "${(originalName || safeName).replace(/\./g, '')}" (no dots)\n`;
+                }
+                message += `3. 🎯 Specify element type: \`submit_content "${originalName || safeName}" --type=personas\`\n`;
+                message += `4. 📁 Check if file exists in portfolio directories\n\n`;
+                message += `📝 **Tip**: The system searches filenames AND metadata names with fuzzy matching.`;
+                return {
+                    success: false,
+                    error: {
+                        success: false,
+                        message,
+                        error: 'CONTENT_NOT_FOUND'
+                    }
+                };
+            }
+            if (detectionResult.matches.length > 1) {
+                // Multiple matches found - ask user to specify type
+                const matchDetails = detectionResult.matches.map(m => `- ${m.type}: ${m.path}`).join('\n');
+                return {
+                    success: false,
+                    error: {
+                        success: false,
+                        message: `Content "${originalName || safeName}" found in multiple element types:\n\n${matchDetails}\n\n` +
+                            `Please specify the element type using the --type parameter to avoid ambiguity.`,
+                        error: 'MULTIPLE_MATCHES_FOUND'
+                    }
+                };
+            }
+            // Single match found - use it
+            const match = detectionResult.matches[0];
+            elementType = match.type;
+            localPath = match.path;
+            logger.info(`Smart detection: Found "${safeName}" as ${elementType}`, {
+                name: safeName,
+                detectedType: elementType,
+                path: localPath
+            });
+        }
+        return {
+            success: true,
+            elementType,
+            localPath
+        };
+    }
+    /**
+     * Validates file size and content security before processing
+     * @param localPath Path to the local file to validate
+     * @returns Validation result with content or error response
+     */
+    async validateFileAndContent(localPath) {
+        // SECURITY ENHANCEMENT (Task #7): Validate file path before processing
+        const pathValidation = await this.validatePortfolioPath(localPath);
+        if (!pathValidation.isValid) {
+            return {
+                success: false,
+                error: pathValidation.error
+            };
+        }
+        // Use the validated safe path for all subsequent operations
+        const safePath = pathValidation.safePath;
+        // Validate file size before reading
+        const stats = await fs.stat(safePath);
+        if (stats.size > FILE_SIZE_LIMITS.MAX_FILE_SIZE) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'RATE_LIMIT_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'SubmitToPortfolioTool.execute',
+                details: `File size ${stats.size} exceeds limit of ${FILE_SIZE_LIMITS.MAX_FILE_SIZE}`
+            });
+            return {
+                success: false,
+                error: {
+                    success: false,
+                    message: `File size exceeds ${FILE_SIZE_LIMITS.MAX_FILE_SIZE_MB}MB limit`,
+                    error: 'FILE_TOO_LARGE'
+                }
+            };
+        }
+        // Validate content security
+        const content = await fs.readFile(safePath, 'utf-8');
+        const validationResult = ContentValidator.validateAndSanitize(content);
+        if (!validationResult.isValid && validationResult.severity === 'critical') {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_INJECTION_ATTEMPT',
+                severity: 'HIGH',
+                source: 'SubmitToPortfolioTool.execute',
+                details: `Critical security issues detected: ${validationResult.detectedPatterns?.join(', ')}`
+            });
+            return {
+                success: false,
+                error: {
+                    success: false,
+                    message: `Content validation failed: ${validationResult.detectedPatterns?.join(', ')}`,
+                    error: 'VALIDATION_FAILED'
+                }
+            };
+        }
+        return {
+            success: true,
+            content
+        };
+    }
+    /**
+     * Prepares metadata for the portfolio element
+     * @param safeName The normalized name of the element
+     * @param elementType The type of the element
+     * @param authStatus Authentication status containing username
+     * @returns Metadata object for the element
+     */
+    prepareElementMetadata(safeName, elementType, authStatus) {
+        return {
+            name: safeName,
+            description: `${elementType} submitted from local portfolio`,
+            author: authStatus.username || 'unknown',
+            created: new Date().toISOString(),
+            updated: new Date().toISOString(),
+            version: '1.0.0'
+        };
+    }
+    /**
+     * Validates GitHub token and checks for expiration before usage
+     * SECURITY ENHANCEMENT (Task #5): Token expiration validation to prevent stale token usage
+     * @param token The GitHub token to validate
+     * @returns Validation result with status and expiration info
+     */
+    async validateTokenBeforeUsage(token) {
+        try {
+            // Check token format first (basic validation)
+            if (!TokenManager.validateTokenFormat(token)) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'TOKEN_VALIDATION_FAILURE',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',
+                    details: 'Token has invalid format'
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'Invalid token format. Please re-authenticate.',
+                        error: 'INVALID_TOKEN_FORMAT'
+                    }
+                };
+            }
+            // Validate token with GitHub API to check expiration and permissions
+            const validationResult = await TokenManager.validateTokenScopes(token, {
+                required: ['repo'],
+                optional: ['user:email']
+            });
+            if (!validationResult.isValid) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'TOKEN_VALIDATION_FAILURE',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',
+                    details: `Token validation failed: ${validationResult.error}`
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'GitHub token is invalid or expired. Please re-authenticate.',
+                        error: 'TOKEN_VALIDATION_FAILED'
+                    }
+                };
+            }
+            // Check if token is near expiration (rate limit reset time can indicate token freshness)
+            let isNearExpiry = false;
+            if (validationResult.rateLimit?.resetTime) {
+                const now = new Date();
+                const timeUntilReset = validationResult.rateLimit.resetTime.getTime() - now.getTime();
+                const oneHour = 60 * 60 * 1000;
+                // Consider token "near expiry" if rate limit reset is more than 23 hours away
+                // (GitHub rate limits reset every hour, so this suggests token age)
+                if (timeUntilReset > 23 * oneHour) {
+                    isNearExpiry = true;
+                    logger.warn('GitHub token may be near expiration', {
+                        tokenPrefix: TokenManager.getTokenPrefix(token),
+                        rateLimitResetTime: validationResult.rateLimit.resetTime,
+                        recommendation: 'Consider re-authenticating for long operations'
+                    });
+                }
+            }
+            // Log successful validation
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_SUCCESS',
+                severity: 'LOW',
+                source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',
+                details: 'GitHub token validated successfully before usage',
+                metadata: {
+                    tokenType: TokenManager.getTokenType(token),
+                    scopes: validationResult.scopes,
+                    rateLimitRemaining: validationResult.rateLimit?.remaining,
+                    isNearExpiry
+                }
+            });
+            return {
+                isValid: true,
+                isNearExpiry
+            };
+        }
+        catch (error) {
+            // Handle rate limit exceeded specifically
+            if (error?.code === 'RATE_LIMIT_EXCEEDED') {
+                logger.warn('Token validation rate limited, allowing operation to proceed with cached status');
+                return { isValid: true }; // Allow to proceed if rate limited, as basic format check passed
+            }
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_FAILURE',
+                severity: 'HIGH',
+                source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',
+                details: `Token validation error: ${error.message || 'unknown error'}`
+            });
+            return {
+                isValid: false,
+                error: {
+                    success: false,
+                    message: 'Unable to validate GitHub token. Please check your connection and try again.',
+                    error: 'TOKEN_VALIDATION_ERROR'
+                }
+            };
+        }
+    }
+    /**
+     * Enhanced path validation for portfolio operations with comprehensive security checks
+     * SECURITY ENHANCEMENT (Task #7): Additional validation for special characters and malicious patterns
+     * @param filePath The file path to validate
+     * @returns Validation result with secure path or error response
+     */
+    async validatePortfolioPath(filePath) {
+        try {
+            // Basic null/undefined check
+            if (!filePath || typeof filePath !== 'string') {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                    details: 'Invalid path provided - null, undefined, or non-string'
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'Invalid file path provided',
+                        error: 'INVALID_PATH'
+                    }
+                };
+            }
+            // Check for suspicious patterns that could indicate path traversal or injection
+            const suspiciousPatterns = [
+                /\.\./, // Path traversal
+                /\/\.\./, // Unix path traversal
+                /\\\.\./, // Windows path traversal
+                /\x00/, // Null bytes
+                /[\x01-\x1f\x7f-\x9f]/, // Control characters
+                /[<>:"|?*]/, // Invalid filename characters on Windows
+                /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i, // Reserved Windows names
+                /^\./, // Hidden files (starting with dot)
+                /\s+$/, // Trailing whitespace
+                /^[\s]*$/, // Only whitespace
+                /%[0-9a-fA-F]{2}/, // URL encoding (potential bypass attempt)
+                /\\x[0-9a-fA-F]{2}/, // Hex encoding
+                /\$\{.*\}/, // Template literal injection
+                /`.*`/, // Backtick injection
+                /[\\\/]{2,}/ // Multiple consecutive slashes
+            ];
+            for (const pattern of suspiciousPatterns) {
+                if (pattern.test(filePath)) {
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'PATH_TRAVERSAL_ATTEMPT',
+                        severity: 'HIGH',
+                        source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                        details: `Suspicious pattern detected in file path: ${pattern.source}`,
+                        metadata: {
+                            pathLength: filePath.length,
+                            pattern: pattern.source
+                        }
+                    });
+                    return {
+                        isValid: false,
+                        error: {
+                            success: false,
+                            message: 'File path contains invalid or suspicious characters',
+                            error: 'SUSPICIOUS_PATH_PATTERN'
+                        }
+                    };
+                }
+            }
+            // Check path length (prevent buffer overflow attempts)
+            const MAX_PATH_LENGTH = process.platform === 'win32' ? 260 : 4096;
+            if (filePath.length > MAX_PATH_LENGTH) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                    details: `File path exceeds maximum length: ${filePath.length} > ${MAX_PATH_LENGTH}`
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'File path is too long',
+                        error: 'PATH_TOO_LONG'
+                    }
+                };
+            }
+            // Normalize path to resolve any relative components safely
+            let normalizedPath;
+            try {
+                // Remove null bytes and normalize
+                const cleanPath = filePath.replace(/\x00/g, '');
+                normalizedPath = path.normalize(cleanPath);
+                // Ensure the normalized path doesn't escape the intended directory
+                if (normalizedPath.includes('..') || normalizedPath.startsWith('/') ||
+                    (process.platform === 'win32' && /^[a-zA-Z]:/.test(normalizedPath))) {
+                    throw new Error('Path normalization resulted in directory traversal');
+                }
+            }
+            catch (error) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'PATH_TRAVERSAL_ATTEMPT',
+                    severity: 'HIGH',
+                    source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                    details: `Path normalization failed: ${error instanceof Error ? error.message : 'unknown error'}`
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'File path could not be safely processed',
+                        error: 'PATH_NORMALIZATION_FAILED'
+                    }
+                };
+            }
+            // Validate file extension (only allow safe extensions for portfolio content)
+            const allowedExtensions = ['.md', '.markdown', '.txt', '.yml', '.yaml', '.json'];
+            const fileExtension = path.extname(normalizedPath).toLowerCase();
+            if (fileExtension && !allowedExtensions.includes(fileExtension)) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'CONTENT_INJECTION_ATTEMPT',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                    details: `Disallowed file extension: ${fileExtension}`,
+                    metadata: {
+                        allowedExtensions: allowedExtensions.join(', ')
+                    }
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: `File extension '${fileExtension}' is not allowed. Allowed extensions: ${allowedExtensions.join(', ')}`,
+                        error: 'INVALID_FILE_EXTENSION'
+                    }
+                };
+            }
+            // Validate filename characters (only allow safe characters)
+            const basename = path.basename(normalizedPath);
+            const safeFilenamePattern = /^[a-zA-Z0-9\-_.\s()[\]{}]+$/;
+            if (basename && !safeFilenamePattern.test(basename)) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'CONTENT_INJECTION_ATTEMPT',
+                    severity: 'MEDIUM',
+                    source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                    details: 'Filename contains potentially dangerous characters',
+                    metadata: {
+                        filename: basename,
+                        allowedPattern: safeFilenamePattern.source
+                    }
+                });
+                return {
+                    isValid: false,
+                    error: {
+                        success: false,
+                        message: 'Filename contains invalid characters. Only letters, numbers, spaces, hyphens, underscores, dots, and common brackets are allowed.',
+                        error: 'INVALID_FILENAME_CHARACTERS'
+                    }
+                };
+            }
+            // Log successful validation
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_INJECTION_ATTEMPT',
+                severity: 'LOW',
+                source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                details: 'File path validation successful',
+                metadata: {
+                    originalPathLength: filePath.length,
+                    normalizedPathLength: normalizedPath.length,
+                    fileExtension: fileExtension || 'none'
+                }
+            });
+            return {
+                isValid: true,
+                safePath: normalizedPath
+            };
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'PATH_TRAVERSAL_ATTEMPT',
+                severity: 'HIGH',
+                source: 'SubmitToPortfolioTool.validatePortfolioPath',
+                details: `Path validation error: ${error instanceof Error ? error.message : 'unknown error'}`
+            });
+            return {
+                isValid: false,
+                error: {
+                    success: false,
+                    message: 'Unable to validate file path. Please check the file path and try again.',
+                    error: 'PATH_VALIDATION_ERROR'
+                }
+            };
+        }
+    }
+    /**
+     * Smart token management for long operations with refresh-like capabilities
+     * SECURITY ENHANCEMENT (Task #14): Token refresh logic for long operations
+     *
+     * Note: GitHub OAuth device flow tokens don't have traditional refresh tokens,
+     * but we can implement smart validation and guidance for long operations
+     *
+     * @param operationType Type of operation being performed
+     * @returns Token management result with recommendations
+     */
+    async manageTokenForLongOperation(operationType) {
+        try {
+            // Get current token
+            const token = await TokenManager.getGitHubTokenAsync();
+            if (!token) {
+                return {
+                    canProceed: false,
+                    error: {
+                        success: false,
+                        message: 'No GitHub token available. Please authenticate first.',
+                        error: 'NO_TOKEN'
+                    }
+                };
+            }
+            // Validate token for the specific operation
+            const validation = await this.validateTokenBeforeUsage(token);
+            if (!validation.isValid) {
+                return {
+                    canProceed: false,
+                    error: validation.error
+                };
+            }
+            // Check if this is a long operation that might benefit from fresh authentication
+            const longOperations = ['portfolio_creation', 'collection_submission'];
+            const isLongOperation = longOperations.includes(operationType);
+            // Get token type to determine refresh capabilities
+            const tokenType = TokenManager.getTokenType(token);
+            let refreshRecommended = false;
+            // For long operations, check token age and recommend refresh if needed
+            if (isLongOperation && validation.isNearExpiry) {
+                refreshRecommended = true;
+                SecurityMonitor.logSecurityEvent({
+                    type: 'TOKEN_VALIDATION_SUCCESS',
+                    severity: 'LOW',
+                    source: 'SubmitToPortfolioTool.manageTokenForLongOperation',
+                    details: 'Long operation detected with aging token - refresh recommended',
+                    metadata: {
+                        operationType,
+                        tokenType,
+                        refreshRecommended: true
+                    }
+                });
+                logger.warn('Long operation with potentially aging token detected', {
+                    operationType,
+                    tokenType,
+                    recommendation: 'Consider re-authenticating if operation fails'
+                });
+            }
+            // For OAuth tokens in long operations, we can provide guidance
+            if (tokenType === 'OAuth Access Token' && isLongOperation) {
+                logger.info('OAuth token detected for long operation', {
+                    operationType,
+                    tokenType,
+                    guidance: 'OAuth tokens are time-limited. If operation fails, re-authenticate using setup_github_auth'
+                });
+            }
+            // Log successful token management
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_SUCCESS',
+                severity: 'LOW',
+                source: 'SubmitToPortfolioTool.manageTokenForLongOperation',
+                details: 'Token management successful for long operation',
+                metadata: {
+                    operationType,
+                    tokenType,
+                    isLongOperation,
+                    refreshRecommended
+                }
+            });
+            return {
+                canProceed: true,
+                token,
+                refreshRecommended
+            };
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'TOKEN_VALIDATION_FAILURE',
+                severity: 'MEDIUM',
+                source: 'SubmitToPortfolioTool.manageTokenForLongOperation',
+                details: `Token management error: ${error.message || 'unknown error'}`
+            });
+            return {
+                canProceed: false,
+                error: {
+                    success: false,
+                    message: 'Unable to manage token for operation. Please check your authentication and try again.',
+                    error: 'TOKEN_MANAGEMENT_ERROR'
+                }
+            };
+        }
+    }
+    /**
+     * Provides user guidance for token refresh when operations fail due to token issues
+     * SECURITY ENHANCEMENT (Task #14): User guidance for authentication refresh
+     */
+    formatTokenRefreshGuidance(operationType, tokenType) {
+        let guidance = '\n\n🔄 **Token Refresh Guidance**:\n';
+        if (tokenType === 'OAuth Access Token') {
+            guidance += '• Your OAuth token may have expired\n';
+            guidance += '• Run `setup_github_auth` to authenticate again\n';
+            guidance += '• This will generate a fresh token for continued access\n';
+        }
+        else if (tokenType === 'Personal Access Token') {
+            guidance += '• Your Personal Access Token may have expired\n';
+            guidance += '• Check your GitHub settings: https://github.com/settings/tokens\n';
+            guidance += '• Generate a new token if needed and update GITHUB_TOKEN environment variable\n';
+        }
+        else {
+            guidance += '• Your GitHub token may have expired or been revoked\n';
+            guidance += '• Re-authenticate using `setup_github_auth`\n';
+            guidance += '• Ensure your token has the required permissions\n';
+        }
+        guidance += `\n**Operation**: ${operationType}\n`;
+        guidance += '**Required scopes**: repo, user:email\n\n';
+        guidance += '💡 **Tip**: Fresh tokens work better for complex operations like portfolio creation.';
+        return guidance;
+    }
+    /**
+     * Sets up GitHub repository access and ensures portfolio repository exists
+     * @param authStatus Authentication status containing username
+     * @returns Setup result or error response
+     */
+    async setupGitHubRepository(authStatus) {
+        // SECURITY ENHANCEMENT (Task #14): Smart token management for long operations
+        const tokenManagement = await this.manageTokenForLongOperation('portfolio_creation');
+        if (!tokenManagement.canProceed) {
+            return {
+                success: false,
+                error: tokenManagement.error
+            };
+        }
+        const token = tokenManagement.token;
+        // Provide user guidance if refresh is recommended for this long operation
+        if (tokenManagement.refreshRecommended) {
+            const tokenType = TokenManager.getTokenType(token);
+            const guidance = this.formatTokenRefreshGuidance('portfolio creation', tokenType);
+            logger.warn(`Token refresh recommended for portfolio creation:${guidance}`);
+        }
+        this.portfolioManager.setToken(token);
+        // Check if portfolio exists and create if needed
+        const username = authStatus.username || 'unknown';
+        const portfolioExists = await this.portfolioManager.checkPortfolioExists(username);
+        if (!portfolioExists) {
+            logger.info('Creating portfolio repository...');
+            // Request consent for portfolio creation
+            const repoUrl = await this.portfolioManager.createPortfolio(username, true);
+            if (!repoUrl) {
+                return {
+                    success: false,
+                    error: {
+                        success: false,
+                        message: 'Failed to create portfolio repository',
+                        error: 'CREATE_FAILED'
+                    }
+                };
+            }
+        }
+        return { success: true };
+    }
+    /**
+     * Submits element to portfolio and handles the complete response workflow
+     * @param safeName The normalized name of the element
+     * @param elementType The type of the element
+     * @param metadata The metadata for the element
+     * @param content The content of the element
+     * @param authStatus Authentication status containing username and token
+     * @returns Complete submission result with success message or error
+     */
+    async submitElementAndHandleResponse(safeName, elementType, metadata, content, authStatus) {
+        // Create element structure to save
+        const element = {
+            type: elementType,
+            metadata,
+            content
+        };
+        // TYPE SAFETY FIX #2: Use adapter pattern instead of complex type casting
+        // Previously: element as unknown as Parameters<typeof this.portfolioManager.saveElement>[0]
+        // Now: Clean adapter pattern that implements IElement interface properly
+        const adapter = new PortfolioElementAdapter(element);
+        // UX IMPROVEMENT: Add retry logic for transient failures
+        const fileUrl = await this.saveElementWithRetry(adapter, safeName, elementType);
+        if (!fileUrl) {
+            return {
+                success: false,
+                message: 'Failed to save element to GitHub portfolio after multiple attempts.\n\n' +
+                    '💡 **Troubleshooting Tips**:\n' +
+                    '• Check your GitHub authentication: `gh auth status`\n' +
+                    '• Verify repository permissions\n' +
+                    '• Try again in a few minutes (GitHub API rate limits)\n' +
+                    '• Check GitHub status: https://status.github.com',
+                error: 'SAVE_FAILED'
+            };
+        }
+        // Log successful submission (DMCP-SEC-006)
+        logger.info(`Successfully submitted ${safeName} to GitHub portfolio`, {
+            elementType,
+            username: authStatus.username,
+            fileUrl
+        });
+        // SECURITY ENHANCEMENT (Task #14): Smart token management for collection submission
+        const collectionTokenManagement = await this.manageTokenForLongOperation('collection_submission');
+        if (!collectionTokenManagement.canProceed) {
+            // Token management failed for collection submission, but main submission succeeded
+            const errorMessage = collectionTokenManagement.error?.message || 'Token management failed';
+            return {
+                success: true,
+                message: `✅ Successfully uploaded ${safeName} to your GitHub portfolio!\n📁 Portfolio URL: ${fileUrl}\n\n⚠️ Collection submission skipped: ${errorMessage}`,
+                url: fileUrl
+            };
+        }
+        const token = collectionTokenManagement.token;
+        // Provide refresh guidance if recommended for collection submission
+        if (collectionTokenManagement.refreshRecommended) {
+            const tokenType = TokenManager.getTokenType(token);
+            logger.info('Collection submission proceeding with aging token', {
+                tokenType,
+                recommendation: 'If collection submission fails, try re-authenticating with setup_github_auth'
+            });
+        }
+        // ENHANCEMENT (Issue #549): Ask user if they want to submit to collection
+        // This completes the community contribution workflow
+        const collectionSubmissionResult = await this.promptForCollectionSubmission({
+            elementName: safeName,
+            elementType,
+            portfolioUrl: fileUrl,
+            username: authStatus.username || 'unknown',
+            metadata,
+            token
+        });
+        // Build the response message based on what happened
+        let message = `✅ Successfully uploaded ${safeName} to your GitHub portfolio!\n`;
+        message += `📁 Portfolio URL: ${fileUrl}\n\n`;
+        if (collectionSubmissionResult.submitted) {
+            message += `🎉 Also submitted to DollhouseMCP collection for community review!\n`;
+            message += `📋 Issue: ${collectionSubmissionResult.issueUrl}`;
+        }
+        else if (collectionSubmissionResult.declined) {
+            message += `💡 You can submit to the collection later using the same command.`;
+        }
+        else if (collectionSubmissionResult.error) {
+            message += `⚠️ Collection submission failed: ${collectionSubmissionResult.error}\n`;
+            message += `💡 You can manually submit at: https://github.com/DollhouseMCP/collection/issues/new`;
+        }
+        return {
+            success: true,
+            message,
+            url: fileUrl
+        };
+    }
+    async execute(params) {
+        try {
+            // Validate and normalize input parameters
+            const validationResult = await this.validateAndNormalizeParams(params);
+            if (!validationResult.success) {
+                return validationResult.error;
+            }
+            const safeName = validationResult.safeName;
+            // Check authentication status
+            const authResult = await this.checkAuthentication();
+            if (!authResult.success) {
+                return authResult.error;
+            }
+            const authStatus = authResult.authStatus;
+            // Find content locally with smart type detection
+            const contentResult = await this.discoverContentWithTypeDetection(safeName, params.type, params.name);
+            if (!contentResult.success) {
+                return contentResult.error;
+            }
+            const elementType = contentResult.elementType;
+            const localPath = contentResult.localPath;
+            // Validate file and content security
+            const securityResult = await this.validateFileAndContent(localPath);
+            if (!securityResult.success) {
+                return securityResult.error;
+            }
+            const content = securityResult.content;
+            // Get user consent (placeholder for now - could add interactive prompt later)
+            logger.info(`Preparing to submit ${safeName} to GitHub portfolio`);
+            // Prepare metadata for element
+            const metadata = this.prepareElementMetadata(safeName, elementType, authStatus);
+            // Set up GitHub repository access
+            const repoResult = await this.setupGitHubRepository(authStatus);
+            if (!repoResult.success) {
+                return repoResult.error;
+            }
+            // Submit element to portfolio and handle collection submission
+            return await this.submitElementAndHandleResponse(safeName, elementType, metadata, content, authStatus);
+        }
+        catch (error) {
+            // SECURITY ENHANCEMENT (Task #14): Enhanced error handling with token refresh guidance
+            ErrorHandler.logError('submitToPortfolio', error, {
+                elementName: params.name,
+                elementType: params.type
+            });
+            // Check if error is token-related and provide refresh guidance
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isTokenError = errorMessage.toLowerCase().includes('token') ||
+                errorMessage.toLowerCase().includes('auth') ||
+                errorMessage.toLowerCase().includes('401') ||
+                errorMessage.toLowerCase().includes('403');
+            let formattedError = ErrorHandler.formatForResponse(error);
+            if (isTokenError) {
+                try {
+                    // Get current token to determine type for guidance
+                    const currentToken = await TokenManager.getGitHubTokenAsync();
+                    if (currentToken) {
+                        const tokenType = TokenManager.getTokenType(currentToken);
+                        const refreshGuidance = this.formatTokenRefreshGuidance('portfolio submission', tokenType);
+                        // Append refresh guidance to error message
+                        if (formattedError.message) {
+                            formattedError.message += refreshGuidance;
+                        }
+                    }
+                }
+                catch (tokenError) {
+                    // If we can't get token info, provide generic guidance
+                    formattedError.message += '\n\n🔄 **Authentication Issue**: Try running `setup_github_auth` to refresh your authentication.';
+                }
+            }
+            return formattedError;
+        }
+    }
+    /**
+     * Prompts user to submit content to the DollhouseMCP collection
+     * ENHANCEMENT (Issue #549): Complete the community contribution workflow
+     */
+    async promptForCollectionSubmission(params) {
+        try {
+            // Create a simple prompt message for the user
+            // Note: In MCP context, we can't do interactive prompts, so we'll need to
+            // either make this automatic or require a parameter
+            // For now, let's check if the user has set an environment variable
+            // to auto-submit to collection (opt-in behavior)
+            const autoSubmit = process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION === 'true';
+            if (!autoSubmit) {
+                // User hasn't opted in to auto-submission
+                logger.info('Collection submission skipped (set DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION=true to enable)');
+                return { submitted: false, declined: true };
+            }
+            logger.info('Auto-submitting to DollhouseMCP collection...');
+            // Create the issue in the collection repository
+            const issueUrl = await this.createCollectionIssue({
+                ...params,
+                token: params.token
+            });
+            if (issueUrl) {
+                logger.info('Successfully created collection submission issue', { issueUrl });
+                return { submitted: true, declined: false, issueUrl };
+            }
+            else {
+                return { submitted: false, declined: false, error: 'Failed to create issue' };
+            }
+        }
+        catch (error) {
+            logger.error('Error in collection submission prompt', { error });
+            return {
+                submitted: false,
+                declined: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Creates an issue in the DollhouseMCP/collection repository
+     * ENHANCEMENT (Issue #549): GitHub API integration for collection submission
+     */
+    async createCollectionIssue(params) {
+        try {
+            // Format the issue title
+            const title = `[${params.elementType}] Add ${params.elementName} by @${params.username}`;
+            // Format the issue body with all relevant information
+            const body = `## New ${params.elementType} Submission
+
+` +
+                `**Name**: ${params.elementName}\n` +
+                `**Author**: @${params.username}\n` +
+                `**Type**: ${params.elementType}\n` +
+                `**Description**: ${params.metadata.description || 'No description provided'}\n\n` +
+                `### Portfolio Link\n` +
+                `${params.portfolioUrl}\n\n` +
+                `### Metadata\n` +
+                `\`\`\`json\n${JSON.stringify(params.metadata, null, 2)}\n\`\`\`\n\n` +
+                `### Review Checklist\n` +
+                `- [ ] Content is appropriate and follows community guidelines\n` +
+                `- [ ] No security vulnerabilities or malicious patterns\n` +
+                `- [ ] Metadata is complete and accurate\n` +
+                `- [ ] Element works as described\n` +
+                `- [ ] No duplicate of existing collection content\n\n` +
+                `---\n` +
+                `*This submission was created automatically via the DollhouseMCP submit_content tool.*`;
+            // Determine labels based on element type
+            const labels = [
+                'contribution', // All submissions get this
+                'pending-review', // Needs review
+                params.elementType.toLowerCase() // Element type label
+            ];
+            // PERFORMANCE OPTIMIZATION (Task #6): Use GitHub rate limiter for API calls
+            // This prevents hitting GitHub rate limits and provides better error handling
+            const issueUrl = await githubRateLimiter.queueRequest('create-collection-issue', async () => {
+                const url = 'https://api.github.com/repos/DollhouseMCP/collection/issues';
+                // Create AbortController for timeout
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), getValidatedTimeout());
+                try {
+                    const response = await fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Accept': 'application/vnd.github.v3+json',
+                            'Authorization': `Bearer ${params.token}`,
+                            'Content-Type': 'application/json',
+                            'User-Agent': 'DollhouseMCP/1.0'
+                        },
+                        body: JSON.stringify({
+                            title,
+                            body,
+                            labels
+                        }),
+                        signal: controller.signal
+                    });
+                    clearTimeout(timeoutId);
+                    // PERFORMANCE OPTIMIZATION (Task #15): Enhanced rate limit logging
+                    // Log rate limit headers for diagnostics
+                    const rateLimitRemaining = response.headers.get('X-RateLimit-Remaining');
+                    const rateLimitReset = response.headers.get('X-RateLimit-Reset');
+                    const rateLimitLimit = response.headers.get('X-RateLimit-Limit');
+                    logger.debug('GitHub API rate limit status', {
+                        operation: 'create-collection-issue',
+                        remaining: rateLimitRemaining,
+                        limit: rateLimitLimit,
+                        resetTime: rateLimitReset ? new Date(parseInt(rateLimitReset) * 1000) : undefined,
+                        responseStatus: response.status
+                    });
+                    // Log warning if approaching rate limit
+                    if (rateLimitRemaining && parseInt(rateLimitRemaining) < 100) {
+                        logger.warn('Approaching GitHub API rate limit', {
+                            operation: 'create-collection-issue',
+                            remaining: rateLimitRemaining,
+                            resetTime: rateLimitReset ? new Date(parseInt(rateLimitReset) * 1000) : undefined,
+                            recommendation: 'Consider reducing API usage frequency or authenticating for higher limits'
+                        });
+                    }
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        logger.error('GitHub API error creating issue', {
+                            status: response.status,
+                            statusText: response.statusText,
+                            error: errorText,
+                            rateLimitRemaining,
+                            rateLimitReset
+                        });
+                        if (response.status === 404) {
+                            logger.error('Collection repository not found or no access');
+                        }
+                        else if (response.status === 403) {
+                            logger.error('Permission denied to create issue in collection repo');
+                        }
+                        else if (response.status === 401) {
+                            logger.error('Authentication failed for collection submission');
+                        }
+                        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+                    }
+                    const data = await response.json();
+                    return data.html_url;
+                }
+                catch (fetchError) {
+                    // Re-throw to outer catch block
+                    throw fetchError;
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+            }, 'high' // High priority for collection submission
+            );
+            return issueUrl;
+        }
+        catch (error) {
+            // Handle timeout specifically
+            if (error.name === 'AbortError') {
+                logger.error(`GitHub API request timeout after ${getValidatedTimeout()}ms`);
+            }
+            else {
+                logger.error('Failed to create collection issue', {
+                    error: error.message || error
+                });
+            }
+            return null;
+        }
+    }
+    async findLocalContent(name, type) {
+        try {
+            // METADATA INDEX FIX: Use portfolio index for fast metadata-based lookups
+            // This solves the critical issue where "Safe Roundtrip Tester" couldn't be found
+            // because findLocalContent only searched filenames, not metadata names
+            const indexManager = PortfolioIndexManager.getInstance();
+            // UX IMPROVEMENT: Enhanced search with fuzzy matching
+            const indexEntry = await indexManager.findByName(name, {
+                elementType: type,
+                fuzzyMatch: true
+            });
+            if (indexEntry) {
+                logger.debug('Found content via metadata index', {
+                    searchName: name,
+                    metadataName: indexEntry.metadata.name,
+                    filename: indexEntry.filename,
+                    filePath: indexEntry.filePath,
+                    type
+                });
+                return indexEntry.filePath;
+            }
+            // FALLBACK: Use original file discovery if index lookup fails
+            // This maintains backward compatibility and handles edge cases
+            logger.debug('Index lookup failed, falling back to file discovery', { name, type });
+            const portfolioManager = PortfolioManager.getInstance();
+            const portfolioDir = portfolioManager.getElementDir(type);
+            // UX IMPROVEMENT: Try multiple search strategies for better user experience
+            let file = await FileDiscoveryUtil.findFile(portfolioDir, name, {
+                extensions: ['.md', '.json', '.yaml', '.yml'],
+                partialMatch: true,
+                cacheResults: true
+            });
+            // If not found, try normalizing the name (e.g., "J.A.R.V.I.S." -> "j-a-r-v-i-s")
+            if (!file) {
+                const normalizedName = name.toLowerCase()
+                    .replace(/[^a-z0-9]/gi, '-') // Replace non-alphanumeric with dashes
+                    .replace(/-+/g, '-') // Replace multiple dashes with single dash
+                    .replace(/^-|-$/g, ''); // Remove leading/trailing dashes
+                if (normalizedName !== name.toLowerCase()) {
+                    logger.debug('Trying normalized name search', {
+                        original: name,
+                        normalized: normalizedName,
+                        type
+                    });
+                    file = await FileDiscoveryUtil.findFile(portfolioDir, normalizedName, {
+                        extensions: ['.md', '.json', '.yaml', '.yml'],
+                        partialMatch: true,
+                        cacheResults: true
+                    });
+                }
+            }
+            // If still not found, try searching by display name patterns
+            if (!file) {
+                // Try common variations like removing dots, spaces, etc.
+                const variations = [
+                    name.replace(/\./g, ''), // Remove dots: "J.A.R.V.I.S." -> "JARVIS"
+                    name.replace(/\s+/g, '-'), // Replace spaces with dashes
+                    name.replace(/[\s\.]/g, ''), // Remove spaces and dots
+                    name.replace(/[\s\.]/g, '-'), // Replace spaces and dots with dashes
+                ].filter(v => v !== name && v.length > 0);
+                for (const variation of variations) {
+                    file = await FileDiscoveryUtil.findFile(portfolioDir, variation, {
+                        extensions: ['.md', '.json', '.yaml', '.yml'],
+                        partialMatch: true,
+                        cacheResults: true
+                    });
+                    if (file) {
+                        logger.debug('Found content using name variation', {
+                            original: name,
+                            variation,
+                            file,
+                            type
+                        });
+                        break;
+                    }
+                }
+            }
+            if (file) {
+                logger.debug('Found local content file via fallback', { name, type, file });
+                return file;
+            }
+            logger.debug('No content found', { name, type });
+            return null;
+        }
+        catch (error) {
+            logger.error('Error finding local content', {
+                name,
+                type,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return null;
+        }
+    }
+    /**
+     * Smart element type detection - searches across ALL element types for content
+     * PERFORMANCE OPTIMIZATION (Task #9): Uses early termination for exact matches
+     * This replaces the previous hardcoded default to PERSONA and enables proper type detection
+     *
+     * @param name The content name to search for
+     * @returns Detection result with found matches across all element types
+     */
+    async detectElementType(name) {
+        try {
+            // PERFORMANCE OPTIMIZATION (Task #9): Use early termination search utility
+            // Create search functions for each element type
+            const elementTypes = Object.values(ElementType);
+            const searchFunctions = elementTypes.map((type) => async () => {
+                try {
+                    const filePath = await this.findLocalContent(name, type);
+                    if (filePath) {
+                        return { type: type, path: filePath };
+                    }
+                    return null;
+                }
+                catch (error) {
+                    // Log unexpected errors but don't fail the search
+                    if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') {
+                        logger.debug(`Error searching ${type} directory for content detection`, {
+                            name,
+                            type,
+                            error: error?.message || String(error),
+                            code: error?.code
+                        });
+                    }
+                    // Return null instead of throwing to let other searches continue
+                    return null;
+                }
+            });
+            // PERFORMANCE OPTIMIZATION (Task #9): Define exact match criteria
+            const isExactMatch = (match) => {
+                const filename = path.basename(match.path, path.extname(match.path));
+                return filename.toLowerCase() === name.toLowerCase();
+            };
+            // Execute searches with early termination optimization
+            const searchResults = await EarlyTerminationSearch.executeWithEarlyTermination(searchFunctions, isExactMatch, {
+                operationName: 'element-type-detection',
+                timeoutAfterExactMatch: 1000, // Wait 1 second for other searches after exact match
+                maxParallelSearches: 8 // Limit concurrent searches to avoid overwhelming the system
+            });
+            // PERFORMANCE OPTIMIZATION (Task #8): Enhanced batch operation reporting
+            const batchResults = {
+                name,
+                totalSearches: searchResults.totalSearches,
+                completedSearches: searchResults.completedSearches,
+                matches: searchResults.matches.length,
+                failures: searchResults.failures.length,
+                exactMatchFound: !!searchResults.exactMatch,
+                exactMatchType: searchResults.exactMatch?.type,
+                earlyTerminationTriggered: searchResults.earlyTerminationTriggered,
+                performanceGain: searchResults.performanceGain,
+                matchedTypes: searchResults.matches.map(m => m.type),
+                failedTypes: searchResults.failures.map(f => elementTypes[f.index]).filter(Boolean)
+            };
+            logger.debug('Element type detection completed with early termination optimization', batchResults);
+            // PERFORMANCE OPTIMIZATION (Task #8): Clear reporting of partial failures
+            if (searchResults.failures.length > 0) {
+                logger.warn('Some element type searches failed during batch operation', {
+                    name,
+                    failures: searchResults.failures.map(f => ({
+                        type: elementTypes[f.index] || 'unknown',
+                        error: f.error.substring(0, 100) // Truncate long error messages
+                    })),
+                    successRate: `${searchResults.completedSearches}/${searchResults.totalSearches}`,
+                    impactOnResults: searchResults.matches.length > 0
+                        ? 'No impact - matches found in successful searches'
+                        : 'Potential impact - no matches found'
+                });
+                // If we have failures and no matches, provide actionable guidance
+                if (searchResults.matches.length === 0 && searchResults.failures.length > 0) {
+                    logger.warn('Batch operation had failures and no matches found', {
+                        name,
+                        recommendation: 'Consider checking file permissions or portfolio structure',
+                        failureCount: searchResults.failures.length,
+                        totalSearches: searchResults.totalSearches
+                    });
+                }
+            }
+            // Log performance gains from early termination
+            if (searchResults.earlyTerminationTriggered) {
+                logger.info('Early termination optimization applied successfully', {
+                    name,
+                    exactMatchType: searchResults.exactMatch?.type,
+                    performanceGain: searchResults.performanceGain,
+                    searchesCompleted: searchResults.completedSearches,
+                    searchesTotal: searchResults.totalSearches
+                });
+            }
+            return {
+                found: searchResults.matches.length > 0,
+                matches: searchResults.matches
+            };
+        }
+        catch (error) {
+            logger.error('Error in element type detection', {
+                name,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Return empty result on detection failure
+            return {
+                found: false,
+                matches: []
+            };
+        }
+    }
+    /**
+     * UX IMPROVEMENT: Generate name suggestions for similar content
+     * PERFORMANCE OPTIMIZATION (Task #8): Enhanced batch operation handling with clear partial failure reporting
+     * Helps users find content when exact matches fail
+     */
+    async generateNameSuggestions(searchName) {
+        try {
+            const suggestions = [];
+            const searchLower = searchName.toLowerCase();
+            const elementTypes = Object.values(ElementType);
+            // Track batch operation results for better diagnostics
+            const batchResults = {
+                searchName,
+                totalTypes: elementTypes.length,
+                successfulScans: 0,
+                failedScans: 0,
+                failureDetails: [],
+                totalSuggestions: 0,
+                suggestionsByType: {}
+            };
+            // Process all element types for suggestions
+            for (const elementType of elementTypes) {
+                try {
+                    const portfolioManager = PortfolioManager.getInstance();
+                    const elementDir = portfolioManager.getElementDir(elementType);
+                    // Get files in this directory
+                    const files = await FileDiscoveryUtil.findFile(elementDir, '*', {
+                        extensions: ['.md', '.json', '.yaml', '.yml'],
+                        partialMatch: false,
+                        cacheResults: true
+                    });
+                    let typeSuggestions = 0;
+                    if (Array.isArray(files)) {
+                        for (const filePath of files) {
+                            const basename = path.basename(filePath, path.extname(filePath));
+                            // Calculate similarity using simple metrics
+                            if (this.calculateSimilarity(searchLower, basename.toLowerCase()) > SEARCH_CONFIG.MIN_SIMILARITY_SCORE) {
+                                suggestions.push({
+                                    name: basename,
+                                    type: elementType
+                                });
+                                typeSuggestions++;
+                            }
+                        }
+                    }
+                    else if (files) {
+                        const basename = path.basename(files, path.extname(files));
+                        if (this.calculateSimilarity(searchLower, basename.toLowerCase()) > SEARCH_CONFIG.MIN_SIMILARITY_SCORE) {
+                            suggestions.push({
+                                name: basename,
+                                type: elementType
+                            });
+                            typeSuggestions++;
+                        }
+                    }
+                    batchResults.successfulScans++;
+                    batchResults.suggestionsByType[elementType] = typeSuggestions;
+                }
+                catch (error) {
+                    // PERFORMANCE OPTIMIZATION (Task #8): Track and report partial failures
+                    batchResults.failedScans++;
+                    batchResults.failureDetails.push({
+                        type: elementType,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    // Log individual failures for diagnostics
+                    logger.debug('Failed to scan element type for suggestions', {
+                        elementType,
+                        searchName,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            batchResults.totalSuggestions = suggestions.length;
+            // PERFORMANCE OPTIMIZATION (Task #8): Comprehensive batch operation reporting
+            logger.debug('Name suggestion batch operation completed', {
+                ...batchResults,
+                successRate: `${batchResults.successfulScans}/${batchResults.totalTypes}`,
+                // Don't log full failure details at debug level to avoid spam
+                hasFailures: batchResults.failedScans > 0
+            });
+            // Report failures clearly if they occurred
+            if (batchResults.failedScans > 0) {
+                logger.warn('Some element type scans failed during name suggestion generation', {
+                    searchName,
+                    failedTypes: batchResults.failureDetails.map(f => f.type),
+                    successfulTypes: batchResults.successfulScans,
+                    impactOnResults: batchResults.totalSuggestions > 0
+                        ? 'Partial impact - suggestions found from successful scans'
+                        : 'Potential impact - no suggestions generated',
+                    recommendation: batchResults.totalSuggestions === 0 && batchResults.failedScans > 0
+                        ? 'Check portfolio directory structure and file permissions'
+                        : 'Suggestion generation partially successful despite some failures'
+                });
+            }
+            // Sort by similarity (higher is better) and return top suggestions
+            const sortedSuggestions = suggestions.sort((a, b) => {
+                const simA = this.calculateSimilarity(searchLower, a.name.toLowerCase());
+                const simB = this.calculateSimilarity(searchLower, b.name.toLowerCase());
+                return simB - simA;
+            });
+            logger.debug('Name suggestions generated successfully', {
+                searchName,
+                totalSuggestions: sortedSuggestions.length,
+                topSuggestions: sortedSuggestions.slice(0, 3).map(s => s.name)
+            });
+            return sortedSuggestions;
+        }
+        catch (error) {
+            logger.warn('Failed to generate name suggestions - batch operation failed completely', {
+                searchName,
+                error: error instanceof Error ? error.message : String(error),
+                recommendation: 'Check portfolio structure and permissions'
+            });
+            return [];
+        }
+    }
+    /**
+     * Simple similarity calculation using Levenshtein-like approach
+     * Returns value between 0 and 1, where 1 is identical
+     */
+    calculateSimilarity(str1, str2) {
+        // Handle exact matches
+        if (str1 === str2)
+            return 1;
+        // Handle substring matches
+        if (str1.includes(str2) || str2.includes(str1))
+            return 0.8;
+        // Handle partial matches
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 0;
+        // Count common characters
+        let common = 0;
+        for (let i = 0; i < shorter.length; i++) {
+            if (longer.includes(shorter[i])) {
+                common++;
+            }
+        }
+        return common / longer.length;
+    }
+    /**
+     * UX IMPROVEMENT: Save element with automatic retry logic for transient failures
+     * Handles common GitHub API issues like rate limits and temporary network problems
+     */
+    async saveElementWithRetry(adapter, elementName, elementType, maxRetries = RETRY_CONFIG.MAX_ATTEMPTS) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                logger.debug(`Attempting to save element (attempt ${attempt}/${maxRetries})`, {
+                    elementName,
+                    elementType,
+                    attempt
+                });
+                const fileUrl = await this.portfolioManager.saveElement(adapter, true);
+                if (fileUrl) {
+                    if (attempt > 1) {
+                        logger.info(`Element saved successfully after ${attempt} attempts`, {
+                            elementName,
+                            elementType,
+                            fileUrl
+                        });
+                    }
+                    return fileUrl;
+                }
+                // If saveElement returns null, treat as a failure but don't retry immediately
+                lastError = new Error(`saveElement returned null on attempt ${attempt}`);
+            }
+            catch (error) {
+                lastError = error;
+                const isRetryable = this.isRetryableError(error);
+                logger.warn(`Save attempt ${attempt} failed`, {
+                    elementName,
+                    elementType,
+                    attempt,
+                    error: error.message,
+                    isRetryable,
+                    willRetry: isRetryable && attempt < maxRetries
+                });
+                // If this is not a retryable error, fail immediately
+                if (!isRetryable) {
+                    logger.error('Non-retryable error encountered, aborting retries', {
+                        elementName,
+                        error: error.message
+                    });
+                    break;
+                }
+                // If we have more attempts, wait before retrying
+                if (attempt < maxRetries) {
+                    const delay = calculateRetryDelay(attempt);
+                    logger.debug(`Waiting ${delay}ms before retry`, { attempt, delay });
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // All attempts failed
+        logger.error(`All ${maxRetries} save attempts failed`, {
+            elementName,
+            elementType,
+            lastError: lastError?.message
+        });
+        return null;
+    }
+    /**
+     * Determine if an error is worth retrying
+     * Retryable: network issues, rate limits, temporary GitHub API problems
+     * Non-retryable: authentication issues, validation errors, permanent failures
+     */
+    isRetryableError(error) {
+        const errorMessage = error?.message?.toLowerCase() || '';
+        const errorCode = error?.code;
+        const statusCode = error?.status || error?.statusCode;
+        // Network and timeout errors
+        if (errorCode === 'ENOTFOUND' || errorCode === 'ECONNRESET' || errorCode === 'ETIMEDOUT') {
+            return true;
+        }
+        // GitHub API rate limits
+        if (statusCode === 429 || errorMessage.includes('rate limit')) {
+            return true;
+        }
+        // Temporary GitHub API issues
+        if (statusCode >= 500 && statusCode < 600) {
+            return true;
+        }
+        // Temporary GitHub API problems
+        if (errorMessage.includes('temporarily unavailable') ||
+            errorMessage.includes('service unavailable') ||
+            errorMessage.includes('internal server error')) {
+            return true;
+        }
+        // Connection issues
+        if (errorMessage.includes('connection') &&
+            (errorMessage.includes('timeout') || errorMessage.includes('reset'))) {
+            return true;
+        }
+        // Don't retry authentication or permission issues
+        if (statusCode === 401 || statusCode === 403 ||
+            errorMessage.includes('unauthorized') ||
+            errorMessage.includes('forbidden') ||
+            errorMessage.includes('authentication')) {
+            return false;
+        }
+        // Don't retry validation errors
+        if (statusCode === 400 || statusCode === 422 ||
+            errorMessage.includes('invalid') ||
+            errorMessage.includes('validation')) {
+            return false;
+        }
+        // Default to not retrying for unknown errors to avoid infinite loops
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"submitToPortfolioTool.js","sourceRoot":"","sources":["../../../src/tools/portfolio/submitToPortfolioTool.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tool for submitting content to GitHub portfolio repositories\n * Replaces the broken issue-based submission with direct repository saves\n * \n * FIXES IMPLEMENTED (PR #503):\n * 1. TYPE SAFETY FIX #1 (Issue #497): Changed apiCache from 'any' to proper APICache type\n * 2. TYPE SAFETY FIX #2 (Issue #497): Replaced complex type casting with PortfolioElementAdapter\n * 3. PERFORMANCE (PR #496 recommendation): Using FileDiscoveryUtil for optimized file search\n */\n\nimport { GitHubAuthManager } from '../../auth/GitHubAuthManager.js';\nimport { PortfolioRepoManager } from '../../portfolio/PortfolioRepoManager.js';\nimport { TokenManager } from '../../security/tokenManager.js';\nimport { ContentValidator } from '../../security/contentValidator.js';\nimport { PortfolioManager } from '../../portfolio/PortfolioManager.js';\nimport { PortfolioIndexManager } from '../../portfolio/PortfolioIndexManager.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { logger } from '../../utils/logger.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { PathValidator } from '../../security/pathValidator.js';\nimport { APICache } from '../../cache/APICache.js';\nimport { PortfolioElementAdapter } from './PortfolioElementAdapter.js';\nimport { FileDiscoveryUtil } from '../../utils/FileDiscoveryUtil.js';\nimport { ErrorHandler, ErrorCategory } from '../../utils/ErrorHandler.js';\nimport { \n  GITHUB_API_TIMEOUT, \n  FILE_SIZE_LIMITS, \n  RETRY_CONFIG, \n  SEARCH_CONFIG,\n  PortfolioElementMetadata,\n  getValidatedTimeout,\n  calculateRetryDelay\n} from '../../config/portfolio-constants.js';\nimport { githubRateLimiter } from '../../utils/GitHubRateLimiter.js';\nimport { EarlyTerminationSearch } from '../../utils/EarlyTerminationSearch.js';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\n\nexport interface SubmitToPortfolioParams {\n  name: string;\n  type?: ElementType;\n}\n\nexport interface PortfolioElement {\n  type: ElementType;\n  metadata: PortfolioElementMetadata;\n  content: string;\n}\n\nexport interface SubmitToPortfolioResult {\n  success: boolean;\n  message: string;\n  url?: string;\n  error?: string;\n}\n\nexport interface ElementDetectionMatch {\n  type: ElementType;\n  path: string;\n}\n\nexport interface ElementDetectionResult {\n  found: boolean;\n  matches: ElementDetectionMatch[];\n}\n\nexport class SubmitToPortfolioTool {\n  private authManager: GitHubAuthManager;\n  private portfolioManager: PortfolioRepoManager;\n  private contentValidator: ContentValidator;\n\n  constructor(apiCache: APICache) {\n    // TYPE SAFETY FIX #1: Proper typing for apiCache parameter\n    // Previously: constructor(apiCache: any)\n    // Now: constructor(apiCache: APICache) with proper import\n    this.authManager = new GitHubAuthManager(apiCache);\n    this.portfolioManager = new PortfolioRepoManager();\n    this.contentValidator = new ContentValidator();\n  }\n\n  /**\n   * Validates and normalizes input parameters to prevent Unicode attacks and ensure data safety\n   * @param params The input parameters from the user\n   * @returns Validation result with normalized name or error response\n   */\n  private async validateAndNormalizeParams(params: SubmitToPortfolioParams): Promise<{\n    success: boolean;\n    safeName?: string;\n    error?: SubmitToPortfolioResult;\n  }> {\n    // Normalize user input to prevent Unicode attacks (DMCP-SEC-004)\n    const normalizedName = UnicodeValidator.normalize(params.name);\n    if (!normalizedName.isValid) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'UNICODE_VALIDATION_ERROR',\n        severity: 'MEDIUM',\n        source: 'SubmitToPortfolioTool.execute',\n        details: `Invalid Unicode in element name: ${normalizedName.detectedIssues?.[0] || 'unknown error'}`\n      });\n      return {\n        success: false,\n        error: {\n          success: false,\n          message: `Invalid characters in element name: ${normalizedName.detectedIssues?.[0] || 'unknown error'}`,\n          error: 'INVALID_INPUT'\n        }\n      };\n    }\n    \n    return {\n      success: true,\n      safeName: normalizedName.normalizedContent\n    };\n  }\n\n  /**\n   * Checks if the user is authenticated with GitHub\n   * @returns Authentication check result with status or error response\n   */\n  private async checkAuthentication(): Promise<{\n    success: boolean;\n    authStatus?: any;\n    error?: SubmitToPortfolioResult;\n  }> {\n    const authStatus = await this.authManager.getAuthStatus();\n    if (!authStatus.isAuthenticated) {\n      // Log authentication required (using existing event type)\n      logger.warn('User attempted portfolio submission without authentication');\n      return {\n        success: false,\n        error: {\n          success: false,\n          message: 'Not authenticated. Please authenticate first using the GitHub OAuth flow.\\n\\n' +\n                   'Visit: https://docs.anthropic.com/en/docs/claude-code/oauth-setup\\n' +\n                   'Or run: gh auth login --web',\n          error: 'NOT_AUTHENTICATED'\n        }\n      };\n    }\n\n    return {\n      success: true,\n      authStatus\n    };\n  }\n\n  /**\n   * Discovers content locally with smart type detection\n   * @param safeName The normalized name to search for\n   * @param explicitType Optional explicit element type provided by user\n   * @param originalName Original user-provided name for error messages\n   * @returns Content discovery result with element type and path or error response\n   */\n  private async discoverContentWithTypeDetection(\n    safeName: string, \n    explicitType?: ElementType, \n    originalName?: string\n  ): Promise<{\n    success: boolean;\n    elementType?: ElementType;\n    localPath?: string;\n    error?: SubmitToPortfolioResult;\n  }> {\n    let elementType = explicitType;\n    let localPath: string | null = null;\n    \n    if (elementType) {\n      // Type explicitly provided - search in that specific directory only\n      localPath = await this.findLocalContent(safeName, elementType);\n      if (!localPath) {\n        // UX IMPROVEMENT: Provide helpful suggestions for finding content\n        const portfolioManager = PortfolioManager.getInstance();\n        const elementDir = portfolioManager.getElementDir(elementType);\n        \n        return {\n          success: false,\n          error: {\n            success: false,\n            message: `Could not find ${elementType} named \"${originalName || safeName}\" in local portfolio.\\n\\n` +\n                    `**Searched in**: ${elementDir}\\n\\n` +\n                    `**Troubleshooting Tips**:\\n` +\n                    `• Check if the file exists using your file explorer\\n` +\n                    `• Try using the exact filename (without extension)\\n` +\n                    `• Use \\`list_portfolio\\` to see all available ${elementType}\\n` +\n                    `• If unsure of the type, omit --type and let the system detect it\\n\\n` +\n                    `**Common name formats that work**:\\n` +\n                    `• \"my-element\" (kebab-case)\\n` +\n                    `• \"My Element\" (with spaces)\\n` +\n                    `• \"MyElement\" (PascalCase)\\n` +\n                    `• Partial matches are supported`,\n            error: 'CONTENT_NOT_FOUND'\n          }\n        };\n      }\n    } else {\n      // CRITICAL FIX: No type provided - implement smart detection across ALL element types\n      // This prevents the previous hardcoded default to PERSONA and enables proper type detection\n      const detectionResult = await this.detectElementType(safeName);\n      \n      if (!detectionResult.found) {\n        // UX IMPROVEMENT: Enhanced guidance with specific suggestions\n        const availableTypes = Object.values(ElementType).join(', ');\n        \n        // Get suggestions for similar names\n        const suggestions = await this.generateNameSuggestions(safeName);\n        \n        let message = `Content \"${originalName || safeName}\" not found in portfolio.\\n\\n`;\n        message += `🔍 **Searched in all element types**: ${availableTypes}\\n\\n`;\n        \n        if (suggestions.length > 0) {\n          message += `💡 **Did you mean one of these?**\\n`;\n          for (const suggestion of suggestions.slice(0, SEARCH_CONFIG.MAX_SUGGESTIONS)) {\n            message += `  • \"${suggestion.name}\" (${suggestion.type})\\n`;\n          }\n          message += `\\n`;\n        }\n        \n        message += `🛠️ **Troubleshooting Steps**:\\n`;\n        message += `1. 📝 Use \\`list_portfolio\\` to see all available content\\n`;\n        message += `2. 🔍 Check exact spelling and try variations:\\n`;\n        message += `   • \"${(originalName || safeName).toLowerCase()}\" (lowercase)\\n`;\n        message += `   • \"${(originalName || safeName).replace(/[^a-z0-9]/gi, '-').toLowerCase()}\" (normalized)\\n`;\n        if ((originalName || safeName).includes('.')) {\n          message += `   • \"${(originalName || safeName).replace(/\\./g, '')}\" (no dots)\\n`;\n        }\n        message += `3. 🎯 Specify element type: \\`submit_content \"${originalName || safeName}\" --type=personas\\`\\n`;\n        message += `4. 📁 Check if file exists in portfolio directories\\n\\n`;\n        message += `📝 **Tip**: The system searches filenames AND metadata names with fuzzy matching.`;\n        \n        return {\n          success: false,\n          error: {\n            success: false,\n            message,\n            error: 'CONTENT_NOT_FOUND'\n          }\n        };\n      }\n      \n      if (detectionResult.matches.length > 1) {\n        // Multiple matches found - ask user to specify type\n        const matchDetails = detectionResult.matches.map(m => `- ${m.type}: ${m.path}`).join('\\n');\n        return {\n          success: false,\n          error: {\n            success: false,\n            message: `Content \"${originalName || safeName}\" found in multiple element types:\\n\\n${matchDetails}\\n\\n` +\n                    `Please specify the element type using the --type parameter to avoid ambiguity.`,\n            error: 'MULTIPLE_MATCHES_FOUND'\n          }\n        };\n      }\n      \n      // Single match found - use it\n      const match = detectionResult.matches[0];\n      elementType = match.type;\n      localPath = match.path;\n      \n      logger.info(`Smart detection: Found \"${safeName}\" as ${elementType}`, { \n        name: safeName,\n        detectedType: elementType,\n        path: localPath\n      });\n    }\n\n    return {\n      success: true,\n      elementType,\n      localPath\n    };\n  }\n\n  /**\n   * Validates file size and content security before processing\n   * @param localPath Path to the local file to validate\n   * @returns Validation result with content or error response\n   */\n  private async validateFileAndContent(localPath: string): Promise<{\n    success: boolean;\n    content?: string;\n    error?: SubmitToPortfolioResult;\n  }> {\n    // SECURITY ENHANCEMENT (Task #7): Validate file path before processing\n    const pathValidation = await this.validatePortfolioPath(localPath);\n    if (!pathValidation.isValid) {\n      return {\n        success: false,\n        error: pathValidation.error\n      };\n    }\n\n    // Use the validated safe path for all subsequent operations\n    const safePath = pathValidation.safePath!;\n\n    // Validate file size before reading\n    const stats = await fs.stat(safePath);\n    if (stats.size > FILE_SIZE_LIMITS.MAX_FILE_SIZE) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'RATE_LIMIT_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'SubmitToPortfolioTool.execute',\n        details: `File size ${stats.size} exceeds limit of ${FILE_SIZE_LIMITS.MAX_FILE_SIZE}`\n      });\n      return {\n        success: false,\n        error: {\n          success: false,\n          message: `File size exceeds ${FILE_SIZE_LIMITS.MAX_FILE_SIZE_MB}MB limit`,\n          error: 'FILE_TOO_LARGE'\n        }\n      };\n    }\n\n    // Validate content security\n    const content = await fs.readFile(safePath, 'utf-8');\n    const validationResult = ContentValidator.validateAndSanitize(content);\n\n    if (!validationResult.isValid && validationResult.severity === 'critical') {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_INJECTION_ATTEMPT',\n        severity: 'HIGH',\n        source: 'SubmitToPortfolioTool.execute',\n        details: `Critical security issues detected: ${validationResult.detectedPatterns?.join(', ')}`\n      });\n      return {\n        success: false,\n        error: {\n          success: false,\n          message: `Content validation failed: ${validationResult.detectedPatterns?.join(', ')}`,\n          error: 'VALIDATION_FAILED'\n        }\n      };\n    }\n\n    return {\n      success: true,\n      content\n    };\n  }\n\n  /**\n   * Prepares metadata for the portfolio element\n   * @param safeName The normalized name of the element\n   * @param elementType The type of the element\n   * @param authStatus Authentication status containing username\n   * @returns Metadata object for the element\n   */\n  private prepareElementMetadata(\n    safeName: string, \n    elementType: ElementType, \n    authStatus: any\n  ): PortfolioElementMetadata {\n    return {\n      name: safeName,\n      description: `${elementType} submitted from local portfolio`,\n      author: authStatus.username || 'unknown',\n      created: new Date().toISOString(),\n      updated: new Date().toISOString(),\n      version: '1.0.0'\n    };\n  }\n\n  /**\n   * Validates GitHub token and checks for expiration before usage\n   * SECURITY ENHANCEMENT (Task #5): Token expiration validation to prevent stale token usage\n   * @param token The GitHub token to validate\n   * @returns Validation result with status and expiration info\n   */\n  private async validateTokenBeforeUsage(token: string): Promise<{\n    isValid: boolean;\n    isNearExpiry?: boolean;\n    error?: SubmitToPortfolioResult;\n  }> {\n    try {\n      // Check token format first (basic validation)\n      if (!TokenManager.validateTokenFormat(token)) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'TOKEN_VALIDATION_FAILURE',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',\n          details: 'Token has invalid format'\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'Invalid token format. Please re-authenticate.',\n            error: 'INVALID_TOKEN_FORMAT'\n          }\n        };\n      }\n\n      // Validate token with GitHub API to check expiration and permissions\n      const validationResult = await TokenManager.validateTokenScopes(token, {\n        required: ['repo'],\n        optional: ['user:email']\n      });\n\n      if (!validationResult.isValid) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'TOKEN_VALIDATION_FAILURE',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',\n          details: `Token validation failed: ${validationResult.error}`\n        });\n\n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'GitHub token is invalid or expired. Please re-authenticate.',\n            error: 'TOKEN_VALIDATION_FAILED'\n          }\n        };\n      }\n\n      // Check if token is near expiration (rate limit reset time can indicate token freshness)\n      let isNearExpiry = false;\n      if (validationResult.rateLimit?.resetTime) {\n        const now = new Date();\n        const timeUntilReset = validationResult.rateLimit.resetTime.getTime() - now.getTime();\n        const oneHour = 60 * 60 * 1000;\n        \n        // Consider token \"near expiry\" if rate limit reset is more than 23 hours away\n        // (GitHub rate limits reset every hour, so this suggests token age)\n        if (timeUntilReset > 23 * oneHour) {\n          isNearExpiry = true;\n          logger.warn('GitHub token may be near expiration', {\n            tokenPrefix: TokenManager.getTokenPrefix(token),\n            rateLimitResetTime: validationResult.rateLimit.resetTime,\n            recommendation: 'Consider re-authenticating for long operations'\n          });\n        }\n      }\n\n      // Log successful validation\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_SUCCESS',\n        severity: 'LOW',\n        source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',\n        details: 'GitHub token validated successfully before usage',\n        metadata: {\n          tokenType: TokenManager.getTokenType(token),\n          scopes: validationResult.scopes,\n          rateLimitRemaining: validationResult.rateLimit?.remaining,\n          isNearExpiry\n        }\n      });\n\n      return {\n        isValid: true,\n        isNearExpiry\n      };\n\n    } catch (error: any) {\n      // Handle rate limit exceeded specifically\n      if (error?.code === 'RATE_LIMIT_EXCEEDED') {\n        logger.warn('Token validation rate limited, allowing operation to proceed with cached status');\n        return { isValid: true }; // Allow to proceed if rate limited, as basic format check passed\n      }\n\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_FAILURE',\n        severity: 'HIGH',\n        source: 'SubmitToPortfolioTool.validateTokenBeforeUsage',\n        details: `Token validation error: ${error.message || 'unknown error'}`\n      });\n\n      return {\n        isValid: false,\n        error: {\n          success: false,\n          message: 'Unable to validate GitHub token. Please check your connection and try again.',\n          error: 'TOKEN_VALIDATION_ERROR'\n        }\n      };\n    }\n  }\n\n  /**\n   * Enhanced path validation for portfolio operations with comprehensive security checks\n   * SECURITY ENHANCEMENT (Task #7): Additional validation for special characters and malicious patterns\n   * @param filePath The file path to validate\n   * @returns Validation result with secure path or error response\n   */\n  private async validatePortfolioPath(filePath: string): Promise<{\n    isValid: boolean;\n    safePath?: string;\n    error?: SubmitToPortfolioResult;\n  }> {\n    try {\n      // Basic null/undefined check\n      if (!filePath || typeof filePath !== 'string') {\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validatePortfolioPath',\n          details: 'Invalid path provided - null, undefined, or non-string'\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'Invalid file path provided',\n            error: 'INVALID_PATH'\n          }\n        };\n      }\n\n      // Check for suspicious patterns that could indicate path traversal or injection\n      const suspiciousPatterns = [\n        /\\.\\./,                    // Path traversal\n        /\\/\\.\\./,                  // Unix path traversal\n        /\\\\\\.\\./,                  // Windows path traversal\n        /\\x00/,                    // Null bytes\n        /[\\x01-\\x1f\\x7f-\\x9f]/,    // Control characters\n        /[<>:\"|?*]/,               // Invalid filename characters on Windows\n        /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i, // Reserved Windows names\n        /^\\./,                     // Hidden files (starting with dot)\n        /\\s+$/,                    // Trailing whitespace\n        /^[\\s]*$/,                 // Only whitespace\n        /%[0-9a-fA-F]{2}/,         // URL encoding (potential bypass attempt)\n        /\\\\x[0-9a-fA-F]{2}/,       // Hex encoding\n        /\\$\\{.*\\}/,                // Template literal injection\n        /`.*`/,                    // Backtick injection\n        /[\\\\\\/]{2,}/               // Multiple consecutive slashes\n      ];\n\n      for (const pattern of suspiciousPatterns) {\n        if (pattern.test(filePath)) {\n          SecurityMonitor.logSecurityEvent({\n            type: 'PATH_TRAVERSAL_ATTEMPT',\n            severity: 'HIGH',\n            source: 'SubmitToPortfolioTool.validatePortfolioPath',\n            details: `Suspicious pattern detected in file path: ${pattern.source}`,\n            metadata: {\n              pathLength: filePath.length,\n              pattern: pattern.source\n            }\n          });\n          \n          return {\n            isValid: false,\n            error: {\n              success: false,\n              message: 'File path contains invalid or suspicious characters',\n              error: 'SUSPICIOUS_PATH_PATTERN'\n            }\n          };\n        }\n      }\n\n      // Check path length (prevent buffer overflow attempts)\n      const MAX_PATH_LENGTH = process.platform === 'win32' ? 260 : 4096;\n      if (filePath.length > MAX_PATH_LENGTH) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validatePortfolioPath',\n          details: `File path exceeds maximum length: ${filePath.length} > ${MAX_PATH_LENGTH}`\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'File path is too long',\n            error: 'PATH_TOO_LONG'\n          }\n        };\n      }\n\n      // Normalize path to resolve any relative components safely\n      let normalizedPath: string;\n      try {\n        // Remove null bytes and normalize\n        const cleanPath = filePath.replace(/\\x00/g, '');\n        normalizedPath = path.normalize(cleanPath);\n        \n        // Ensure the normalized path doesn't escape the intended directory\n        if (normalizedPath.includes('..') || normalizedPath.startsWith('/') || \n            (process.platform === 'win32' && /^[a-zA-Z]:/.test(normalizedPath))) {\n          throw new Error('Path normalization resulted in directory traversal');\n        }\n      } catch (error) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'PATH_TRAVERSAL_ATTEMPT',\n          severity: 'HIGH',\n          source: 'SubmitToPortfolioTool.validatePortfolioPath',\n          details: `Path normalization failed: ${error instanceof Error ? error.message : 'unknown error'}`\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'File path could not be safely processed',\n            error: 'PATH_NORMALIZATION_FAILED'\n          }\n        };\n      }\n\n      // Validate file extension (only allow safe extensions for portfolio content)\n      const allowedExtensions = ['.md', '.markdown', '.txt', '.yml', '.yaml', '.json'];\n      const fileExtension = path.extname(normalizedPath).toLowerCase();\n      \n      if (fileExtension && !allowedExtensions.includes(fileExtension)) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_INJECTION_ATTEMPT',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validatePortfolioPath',\n          details: `Disallowed file extension: ${fileExtension}`,\n          metadata: {\n            allowedExtensions: allowedExtensions.join(', ')\n          }\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: `File extension '${fileExtension}' is not allowed. Allowed extensions: ${allowedExtensions.join(', ')}`,\n            error: 'INVALID_FILE_EXTENSION'\n          }\n        };\n      }\n\n      // Validate filename characters (only allow safe characters)\n      const basename = path.basename(normalizedPath);\n      const safeFilenamePattern = /^[a-zA-Z0-9\\-_.\\s()[\\]{}]+$/;\n      \n      if (basename && !safeFilenamePattern.test(basename)) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_INJECTION_ATTEMPT',\n          severity: 'MEDIUM',\n          source: 'SubmitToPortfolioTool.validatePortfolioPath',\n          details: 'Filename contains potentially dangerous characters',\n          metadata: {\n            filename: basename,\n            allowedPattern: safeFilenamePattern.source\n          }\n        });\n        \n        return {\n          isValid: false,\n          error: {\n            success: false,\n            message: 'Filename contains invalid characters. Only letters, numbers, spaces, hyphens, underscores, dots, and common brackets are allowed.',\n            error: 'INVALID_FILENAME_CHARACTERS'\n          }\n        };\n      }\n\n      // Log successful validation\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_INJECTION_ATTEMPT',\n        severity: 'LOW',\n        source: 'SubmitToPortfolioTool.validatePortfolioPath',\n        details: 'File path validation successful',\n        metadata: {\n          originalPathLength: filePath.length,\n          normalizedPathLength: normalizedPath.length,\n          fileExtension: fileExtension || 'none'\n        }\n      });\n\n      return {\n        isValid: true,\n        safePath: normalizedPath\n      };\n\n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'HIGH',\n        source: 'SubmitToPortfolioTool.validatePortfolioPath',\n        details: `Path validation error: ${error instanceof Error ? error.message : 'unknown error'}`\n      });\n      \n      return {\n        isValid: false,\n        error: {\n          success: false,\n          message: 'Unable to validate file path. Please check the file path and try again.',\n          error: 'PATH_VALIDATION_ERROR'\n        }\n      };\n    }\n  }\n\n  /**\n   * Smart token management for long operations with refresh-like capabilities\n   * SECURITY ENHANCEMENT (Task #14): Token refresh logic for long operations\n   * \n   * Note: GitHub OAuth device flow tokens don't have traditional refresh tokens,\n   * but we can implement smart validation and guidance for long operations\n   * \n   * @param operationType Type of operation being performed\n   * @returns Token management result with recommendations\n   */\n  private async manageTokenForLongOperation(operationType: 'portfolio_creation' | 'collection_submission' | 'file_upload'): Promise<{\n    canProceed: boolean;\n    token?: string;\n    refreshRecommended?: boolean;\n    error?: SubmitToPortfolioResult;\n  }> {\n    try {\n      // Get current token\n      const token = await TokenManager.getGitHubTokenAsync();\n      if (!token) {\n        return {\n          canProceed: false,\n          error: {\n            success: false,\n            message: 'No GitHub token available. Please authenticate first.',\n            error: 'NO_TOKEN'\n          }\n        };\n      }\n\n      // Validate token for the specific operation\n      const validation = await this.validateTokenBeforeUsage(token);\n      if (!validation.isValid) {\n        return {\n          canProceed: false,\n          error: validation.error\n        };\n      }\n\n      // Check if this is a long operation that might benefit from fresh authentication\n      const longOperations = ['portfolio_creation', 'collection_submission'];\n      const isLongOperation = longOperations.includes(operationType);\n\n      // Get token type to determine refresh capabilities\n      const tokenType = TokenManager.getTokenType(token);\n      let refreshRecommended = false;\n\n      // For long operations, check token age and recommend refresh if needed\n      if (isLongOperation && validation.isNearExpiry) {\n        refreshRecommended = true;\n        \n        SecurityMonitor.logSecurityEvent({\n          type: 'TOKEN_VALIDATION_SUCCESS',\n          severity: 'LOW',\n          source: 'SubmitToPortfolioTool.manageTokenForLongOperation',\n          details: 'Long operation detected with aging token - refresh recommended',\n          metadata: {\n            operationType,\n            tokenType,\n            refreshRecommended: true\n          }\n        });\n\n        logger.warn('Long operation with potentially aging token detected', {\n          operationType,\n          tokenType,\n          recommendation: 'Consider re-authenticating if operation fails'\n        });\n      }\n\n      // For OAuth tokens in long operations, we can provide guidance\n      if (tokenType === 'OAuth Access Token' && isLongOperation) {\n        logger.info('OAuth token detected for long operation', {\n          operationType,\n          tokenType,\n          guidance: 'OAuth tokens are time-limited. If operation fails, re-authenticate using setup_github_auth'\n        });\n      }\n\n      // Log successful token management\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_SUCCESS',\n        severity: 'LOW',\n        source: 'SubmitToPortfolioTool.manageTokenForLongOperation',\n        details: 'Token management successful for long operation',\n        metadata: {\n          operationType,\n          tokenType,\n          isLongOperation,\n          refreshRecommended\n        }\n      });\n\n      return {\n        canProceed: true,\n        token,\n        refreshRecommended\n      };\n\n    } catch (error: any) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'TOKEN_VALIDATION_FAILURE',\n        severity: 'MEDIUM',\n        source: 'SubmitToPortfolioTool.manageTokenForLongOperation',\n        details: `Token management error: ${error.message || 'unknown error'}`\n      });\n\n      return {\n        canProceed: false,\n        error: {\n          success: false,\n          message: 'Unable to manage token for operation. Please check your authentication and try again.',\n          error: 'TOKEN_MANAGEMENT_ERROR'\n        }\n      };\n    }\n  }\n\n  /**\n   * Provides user guidance for token refresh when operations fail due to token issues\n   * SECURITY ENHANCEMENT (Task #14): User guidance for authentication refresh\n   */\n  private formatTokenRefreshGuidance(operationType: string, tokenType: string): string {\n    let guidance = '\\n\\n🔄 **Token Refresh Guidance**:\\n';\n    \n    if (tokenType === 'OAuth Access Token') {\n      guidance += '• Your OAuth token may have expired\\n';\n      guidance += '• Run `setup_github_auth` to authenticate again\\n';\n      guidance += '• This will generate a fresh token for continued access\\n';\n    } else if (tokenType === 'Personal Access Token') {\n      guidance += '• Your Personal Access Token may have expired\\n';\n      guidance += '• Check your GitHub settings: https://github.com/settings/tokens\\n';\n      guidance += '• Generate a new token if needed and update GITHUB_TOKEN environment variable\\n';\n    } else {\n      guidance += '• Your GitHub token may have expired or been revoked\\n';\n      guidance += '• Re-authenticate using `setup_github_auth`\\n';\n      guidance += '• Ensure your token has the required permissions\\n';\n    }\n\n    guidance += `\\n**Operation**: ${operationType}\\n`;\n    guidance += '**Required scopes**: repo, user:email\\n\\n';\n    guidance += '💡 **Tip**: Fresh tokens work better for complex operations like portfolio creation.';\n\n    return guidance;\n  }\n\n  /**\n   * Sets up GitHub repository access and ensures portfolio repository exists\n   * @param authStatus Authentication status containing username\n   * @returns Setup result or error response\n   */\n  private async setupGitHubRepository(authStatus: any): Promise<{\n    success: boolean;\n    error?: SubmitToPortfolioResult;\n  }> {\n    // SECURITY ENHANCEMENT (Task #14): Smart token management for long operations\n    const tokenManagement = await this.manageTokenForLongOperation('portfolio_creation');\n    if (!tokenManagement.canProceed) {\n      return {\n        success: false,\n        error: tokenManagement.error\n      };\n    }\n\n    const token = tokenManagement.token!;\n\n    // Provide user guidance if refresh is recommended for this long operation\n    if (tokenManagement.refreshRecommended) {\n      const tokenType = TokenManager.getTokenType(token);\n      const guidance = this.formatTokenRefreshGuidance('portfolio creation', tokenType);\n      logger.warn(`Token refresh recommended for portfolio creation:${guidance}`);\n    }\n\n    this.portfolioManager.setToken(token);\n\n    // Check if portfolio exists and create if needed\n    const username = authStatus.username || 'unknown';\n    const portfolioExists = await this.portfolioManager.checkPortfolioExists(username);\n    \n    if (!portfolioExists) {\n      logger.info('Creating portfolio repository...');\n      // Request consent for portfolio creation\n      const repoUrl = await this.portfolioManager.createPortfolio(username, true);\n      if (!repoUrl) {\n        return {\n          success: false,\n          error: {\n            success: false,\n            message: 'Failed to create portfolio repository',\n            error: 'CREATE_FAILED'\n          }\n        };\n      }\n    }\n\n    return { success: true };\n  }\n\n  /**\n   * Submits element to portfolio and handles the complete response workflow\n   * @param safeName The normalized name of the element\n   * @param elementType The type of the element\n   * @param metadata The metadata for the element\n   * @param content The content of the element\n   * @param authStatus Authentication status containing username and token\n   * @returns Complete submission result with success message or error\n   */\n  private async submitElementAndHandleResponse(\n    safeName: string,\n    elementType: ElementType,\n    metadata: PortfolioElementMetadata,\n    content: string,\n    authStatus: any\n  ): Promise<SubmitToPortfolioResult> {\n    // Create element structure to save\n    const element: PortfolioElement = {\n      type: elementType,\n      metadata,\n      content\n    };\n    \n    // TYPE SAFETY FIX #2: Use adapter pattern instead of complex type casting\n    // Previously: element as unknown as Parameters<typeof this.portfolioManager.saveElement>[0]\n    // Now: Clean adapter pattern that implements IElement interface properly\n    const adapter = new PortfolioElementAdapter(element);\n    \n    // UX IMPROVEMENT: Add retry logic for transient failures\n    const fileUrl = await this.saveElementWithRetry(adapter, safeName, elementType);\n    \n    if (!fileUrl) {\n      return {\n        success: false,\n        message: 'Failed to save element to GitHub portfolio after multiple attempts.\\n\\n' +\n                '💡 **Troubleshooting Tips**:\\n' +\n                '• Check your GitHub authentication: `gh auth status`\\n' +\n                '• Verify repository permissions\\n' +\n                '• Try again in a few minutes (GitHub API rate limits)\\n' +\n                '• Check GitHub status: https://status.github.com',\n        error: 'SAVE_FAILED'\n      };\n    }\n\n    // Log successful submission (DMCP-SEC-006)\n    logger.info(`Successfully submitted ${safeName} to GitHub portfolio`, {\n      elementType,\n      username: authStatus.username,\n      fileUrl\n    });\n\n    // SECURITY ENHANCEMENT (Task #14): Smart token management for collection submission\n    const collectionTokenManagement = await this.manageTokenForLongOperation('collection_submission');\n    if (!collectionTokenManagement.canProceed) {\n      // Token management failed for collection submission, but main submission succeeded\n      const errorMessage = collectionTokenManagement.error?.message || 'Token management failed';\n      return {\n        success: true,\n        message: `✅ Successfully uploaded ${safeName} to your GitHub portfolio!\\n📁 Portfolio URL: ${fileUrl}\\n\\n⚠️ Collection submission skipped: ${errorMessage}`,\n        url: fileUrl\n      };\n    }\n\n    const token = collectionTokenManagement.token!;\n\n    // Provide refresh guidance if recommended for collection submission\n    if (collectionTokenManagement.refreshRecommended) {\n      const tokenType = TokenManager.getTokenType(token);\n      logger.info('Collection submission proceeding with aging token', {\n        tokenType,\n        recommendation: 'If collection submission fails, try re-authenticating with setup_github_auth'\n      });\n    }\n\n    // ENHANCEMENT (Issue #549): Ask user if they want to submit to collection\n    // This completes the community contribution workflow\n    const collectionSubmissionResult = await this.promptForCollectionSubmission({\n      elementName: safeName,\n      elementType,\n      portfolioUrl: fileUrl,\n      username: authStatus.username || 'unknown',\n      metadata,\n      token\n    });\n\n    // Build the response message based on what happened\n    let message = `✅ Successfully uploaded ${safeName} to your GitHub portfolio!\\n`;\n    message += `📁 Portfolio URL: ${fileUrl}\\n\\n`;\n    \n    if (collectionSubmissionResult.submitted) {\n      message += `🎉 Also submitted to DollhouseMCP collection for community review!\\n`;\n      message += `📋 Issue: ${collectionSubmissionResult.issueUrl}`;\n    } else if (collectionSubmissionResult.declined) {\n      message += `💡 You can submit to the collection later using the same command.`;\n    } else if (collectionSubmissionResult.error) {\n      message += `⚠️ Collection submission failed: ${collectionSubmissionResult.error}\\n`;\n      message += `💡 You can manually submit at: https://github.com/DollhouseMCP/collection/issues/new`;\n    }\n\n    return {\n      success: true,\n      message,\n      url: fileUrl\n    };\n  }\n\n  async execute(params: SubmitToPortfolioParams): Promise<SubmitToPortfolioResult> {\n    try {\n      // Validate and normalize input parameters\n      const validationResult = await this.validateAndNormalizeParams(params);\n      if (!validationResult.success) {\n        return validationResult.error!;\n      }\n      const safeName = validationResult.safeName!;\n\n      // Check authentication status\n      const authResult = await this.checkAuthentication();\n      if (!authResult.success) {\n        return authResult.error!;\n      }\n      const authStatus = authResult.authStatus!;\n\n      // Find content locally with smart type detection\n      const contentResult = await this.discoverContentWithTypeDetection(safeName!, params.type, params.name);\n      if (!contentResult.success) {\n        return contentResult.error!;\n      }\n      const elementType = contentResult.elementType!;\n      const localPath = contentResult.localPath!;\n\n      // Validate file and content security\n      const securityResult = await this.validateFileAndContent(localPath);\n      if (!securityResult.success) {\n        return securityResult.error!;\n      }\n      const content = securityResult.content!;\n\n      // Get user consent (placeholder for now - could add interactive prompt later)\n      logger.info(`Preparing to submit ${safeName} to GitHub portfolio`);\n\n      // Prepare metadata for element\n      const metadata = this.prepareElementMetadata(safeName!, elementType, authStatus);\n\n      // Set up GitHub repository access\n      const repoResult = await this.setupGitHubRepository(authStatus);\n      if (!repoResult.success) {\n        return repoResult.error!;\n      }\n\n      // Submit element to portfolio and handle collection submission\n      return await this.submitElementAndHandleResponse(\n        safeName!, \n        elementType, \n        metadata, \n        content, \n        authStatus\n      );\n\n    } catch (error) {\n      // SECURITY ENHANCEMENT (Task #14): Enhanced error handling with token refresh guidance\n      ErrorHandler.logError('submitToPortfolio', error, {\n        elementName: params.name,\n        elementType: params.type\n      });\n\n      // Check if error is token-related and provide refresh guidance\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      const isTokenError = errorMessage.toLowerCase().includes('token') || \n                          errorMessage.toLowerCase().includes('auth') ||\n                          errorMessage.toLowerCase().includes('401') ||\n                          errorMessage.toLowerCase().includes('403');\n\n      let formattedError = ErrorHandler.formatForResponse(error);\n\n      if (isTokenError) {\n        try {\n          // Get current token to determine type for guidance\n          const currentToken = await TokenManager.getGitHubTokenAsync();\n          if (currentToken) {\n            const tokenType = TokenManager.getTokenType(currentToken);\n            const refreshGuidance = this.formatTokenRefreshGuidance('portfolio submission', tokenType);\n            \n            // Append refresh guidance to error message\n            if (formattedError.message) {\n              formattedError.message += refreshGuidance;\n            }\n          }\n        } catch (tokenError) {\n          // If we can't get token info, provide generic guidance\n          formattedError.message += '\\n\\n🔄 **Authentication Issue**: Try running `setup_github_auth` to refresh your authentication.';\n        }\n      }\n\n      return formattedError;\n    }\n  }\n\n  /**\n   * Prompts user to submit content to the DollhouseMCP collection\n   * ENHANCEMENT (Issue #549): Complete the community contribution workflow\n   */\n  private async promptForCollectionSubmission(params: {\n    elementName: string;\n    elementType: ElementType;\n    portfolioUrl: string;\n    username: string;\n    metadata: PortfolioElementMetadata;\n    token: string;\n  }): Promise<{ submitted: boolean; declined: boolean; error?: string; issueUrl?: string }> {\n    try {\n      // Create a simple prompt message for the user\n      // Note: In MCP context, we can't do interactive prompts, so we'll need to\n      // either make this automatic or require a parameter\n      \n      // For now, let's check if the user has set an environment variable\n      // to auto-submit to collection (opt-in behavior)\n      const autoSubmit = process.env.DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION === 'true';\n      \n      if (!autoSubmit) {\n        // User hasn't opted in to auto-submission\n        logger.info('Collection submission skipped (set DOLLHOUSE_AUTO_SUBMIT_TO_COLLECTION=true to enable)');\n        return { submitted: false, declined: true };\n      }\n\n      logger.info('Auto-submitting to DollhouseMCP collection...');\n\n      // Create the issue in the collection repository\n      const issueUrl = await this.createCollectionIssue({\n        ...params,\n        token: params.token\n      });\n\n      if (issueUrl) {\n        logger.info('Successfully created collection submission issue', { issueUrl });\n        return { submitted: true, declined: false, issueUrl };\n      } else {\n        return { submitted: false, declined: false, error: 'Failed to create issue' };\n      }\n\n    } catch (error) {\n      logger.error('Error in collection submission prompt', { error });\n      return {\n        submitted: false,\n        declined: false,\n        error: error instanceof Error ? error.message : 'Unknown error'\n      };\n    }\n  }\n\n  /**\n   * Creates an issue in the DollhouseMCP/collection repository\n   * ENHANCEMENT (Issue #549): GitHub API integration for collection submission\n   */\n  private async createCollectionIssue(params: {\n    elementName: string;\n    elementType: ElementType;\n    portfolioUrl: string;\n    username: string;\n    metadata: PortfolioElementMetadata;\n    token: string;\n  }): Promise<string | null> {\n    try {\n\n      // Format the issue title\n      const title = `[${params.elementType}] Add ${params.elementName} by @${params.username}`;\n\n      // Format the issue body with all relevant information\n      const body = `## New ${params.elementType} Submission\n\n` +\n        `**Name**: ${params.elementName}\\n` +\n        `**Author**: @${params.username}\\n` +\n        `**Type**: ${params.elementType}\\n` +\n        `**Description**: ${params.metadata.description || 'No description provided'}\\n\\n` +\n        `### Portfolio Link\\n` +\n        `${params.portfolioUrl}\\n\\n` +\n        `### Metadata\\n` +\n        `\\`\\`\\`json\\n${JSON.stringify(params.metadata, null, 2)}\\n\\`\\`\\`\\n\\n` +\n        `### Review Checklist\\n` +\n        `- [ ] Content is appropriate and follows community guidelines\\n` +\n        `- [ ] No security vulnerabilities or malicious patterns\\n` +\n        `- [ ] Metadata is complete and accurate\\n` +\n        `- [ ] Element works as described\\n` +\n        `- [ ] No duplicate of existing collection content\\n\\n` +\n        `---\\n` +\n        `*This submission was created automatically via the DollhouseMCP submit_content tool.*`;\n\n      // Determine labels based on element type\n      const labels = [\n        'contribution',  // All submissions get this\n        'pending-review', // Needs review\n        params.elementType.toLowerCase() // Element type label\n      ];\n\n      // PERFORMANCE OPTIMIZATION (Task #6): Use GitHub rate limiter for API calls\n      // This prevents hitting GitHub rate limits and provides better error handling\n      const issueUrl = await githubRateLimiter.queueRequest(\n        'create-collection-issue',\n        async () => {\n          const url = 'https://api.github.com/repos/DollhouseMCP/collection/issues';\n          \n          // Create AbortController for timeout\n          const controller = new AbortController();\n          const timeoutId = setTimeout(() => controller.abort(), getValidatedTimeout());\n          \n          try {\n            const response = await fetch(url, {\n              method: 'POST',\n              headers: {\n                'Accept': 'application/vnd.github.v3+json',\n                'Authorization': `Bearer ${params.token}`,\n                'Content-Type': 'application/json',\n                'User-Agent': 'DollhouseMCP/1.0'\n              },\n              body: JSON.stringify({\n                title,\n                body,\n                labels\n              }),\n              signal: controller.signal\n            });\n            \n            clearTimeout(timeoutId);\n\n            // PERFORMANCE OPTIMIZATION (Task #15): Enhanced rate limit logging\n            // Log rate limit headers for diagnostics\n            const rateLimitRemaining = response.headers.get('X-RateLimit-Remaining');\n            const rateLimitReset = response.headers.get('X-RateLimit-Reset');\n            const rateLimitLimit = response.headers.get('X-RateLimit-Limit');\n            \n            logger.debug('GitHub API rate limit status', {\n              operation: 'create-collection-issue',\n              remaining: rateLimitRemaining,\n              limit: rateLimitLimit,\n              resetTime: rateLimitReset ? new Date(parseInt(rateLimitReset) * 1000) : undefined,\n              responseStatus: response.status\n            });\n            \n            // Log warning if approaching rate limit\n            if (rateLimitRemaining && parseInt(rateLimitRemaining) < 100) {\n              logger.warn('Approaching GitHub API rate limit', {\n                operation: 'create-collection-issue',\n                remaining: rateLimitRemaining,\n                resetTime: rateLimitReset ? new Date(parseInt(rateLimitReset) * 1000) : undefined,\n                recommendation: 'Consider reducing API usage frequency or authenticating for higher limits'\n              });\n            }\n\n            if (!response.ok) {\n              const errorText = await response.text();\n              logger.error('GitHub API error creating issue', { \n                status: response.status, \n                statusText: response.statusText,\n                error: errorText,\n                rateLimitRemaining,\n                rateLimitReset\n              });\n              \n              if (response.status === 404) {\n                logger.error('Collection repository not found or no access');\n              } else if (response.status === 403) {\n                logger.error('Permission denied to create issue in collection repo');\n              } else if (response.status === 401) {\n                logger.error('Authentication failed for collection submission');\n              }\n              throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);\n            }\n\n            const data = await response.json();\n            return data.html_url;\n            \n          } catch (fetchError: any) {\n            // Re-throw to outer catch block\n            throw fetchError;\n          } finally {\n            clearTimeout(timeoutId);\n          }\n        },\n        'high' // High priority for collection submission\n      );\n      \n      return issueUrl;\n\n    } catch (error: any) {\n      // Handle timeout specifically\n      if (error.name === 'AbortError') {\n        logger.error(`GitHub API request timeout after ${getValidatedTimeout()}ms`);\n      } else {\n        logger.error('Failed to create collection issue', { \n          error: error.message || error\n        });\n      }\n      return null;\n    }\n  }\n\n  private async findLocalContent(name: string, type: ElementType): Promise<string | null> {\n    try {\n      // METADATA INDEX FIX: Use portfolio index for fast metadata-based lookups\n      // This solves the critical issue where \"Safe Roundtrip Tester\" couldn't be found\n      // because findLocalContent only searched filenames, not metadata names\n      const indexManager = PortfolioIndexManager.getInstance();\n      \n      // UX IMPROVEMENT: Enhanced search with fuzzy matching\n      const indexEntry = await indexManager.findByName(name, { \n        elementType: type,\n        fuzzyMatch: true\n      });\n      \n      if (indexEntry) {\n        logger.debug('Found content via metadata index', { \n          searchName: name, \n          metadataName: indexEntry.metadata.name,\n          filename: indexEntry.filename,\n          filePath: indexEntry.filePath,\n          type \n        });\n        return indexEntry.filePath;\n      }\n      \n      // FALLBACK: Use original file discovery if index lookup fails\n      // This maintains backward compatibility and handles edge cases\n      logger.debug('Index lookup failed, falling back to file discovery', { name, type });\n      \n      const portfolioManager = PortfolioManager.getInstance();\n      const portfolioDir = portfolioManager.getElementDir(type);\n      \n      // UX IMPROVEMENT: Try multiple search strategies for better user experience\n      let file = await FileDiscoveryUtil.findFile(portfolioDir, name, {\n        extensions: ['.md', '.json', '.yaml', '.yml'],\n        partialMatch: true,\n        cacheResults: true\n      });\n      \n      // If not found, try normalizing the name (e.g., \"J.A.R.V.I.S.\" -> \"j-a-r-v-i-s\")\n      if (!file) {\n        const normalizedName = name.toLowerCase()\n          .replace(/[^a-z0-9]/gi, '-')  // Replace non-alphanumeric with dashes\n          .replace(/-+/g, '-')         // Replace multiple dashes with single dash\n          .replace(/^-|-$/g, '');      // Remove leading/trailing dashes\n          \n        if (normalizedName !== name.toLowerCase()) {\n          logger.debug('Trying normalized name search', { \n            original: name, \n            normalized: normalizedName,\n            type \n          });\n          \n          file = await FileDiscoveryUtil.findFile(portfolioDir, normalizedName, {\n            extensions: ['.md', '.json', '.yaml', '.yml'],\n            partialMatch: true,\n            cacheResults: true\n          });\n        }\n      }\n      \n      // If still not found, try searching by display name patterns\n      if (!file) {\n        // Try common variations like removing dots, spaces, etc.\n        const variations = [\n          name.replace(/\\./g, ''),        // Remove dots: \"J.A.R.V.I.S.\" -> \"JARVIS\"\n          name.replace(/\\s+/g, '-'),      // Replace spaces with dashes\n          name.replace(/[\\s\\.]/g, ''),    // Remove spaces and dots\n          name.replace(/[\\s\\.]/g, '-'),   // Replace spaces and dots with dashes\n        ].filter(v => v !== name && v.length > 0);\n        \n        for (const variation of variations) {\n          file = await FileDiscoveryUtil.findFile(portfolioDir, variation, {\n            extensions: ['.md', '.json', '.yaml', '.yml'],\n            partialMatch: true,\n            cacheResults: true\n          });\n          \n          if (file) {\n            logger.debug('Found content using name variation', {\n              original: name,\n              variation,\n              file,\n              type\n            });\n            break;\n          }\n        }\n      }\n      \n      if (file) {\n        logger.debug('Found local content file via fallback', { name, type, file });\n        return file;\n      }\n      \n      logger.debug('No content found', { name, type });\n      return null;\n      \n    } catch (error) {\n      logger.error('Error finding local content', {\n        name,\n        type,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      return null;\n    }\n  }\n\n  /**\n   * Smart element type detection - searches across ALL element types for content\n   * PERFORMANCE OPTIMIZATION (Task #9): Uses early termination for exact matches\n   * This replaces the previous hardcoded default to PERSONA and enables proper type detection\n   * \n   * @param name The content name to search for\n   * @returns Detection result with found matches across all element types\n   */\n  private async detectElementType(name: string): Promise<ElementDetectionResult> {\n    try {\n      // PERFORMANCE OPTIMIZATION (Task #9): Use early termination search utility\n      // Create search functions for each element type\n      const elementTypes = Object.values(ElementType);\n      const searchFunctions = elementTypes.map((type) => async () => {\n        try {\n          const filePath = await this.findLocalContent(name, type);\n          if (filePath) {\n            return { type: type as ElementType, path: filePath };\n          }\n          return null;\n        } catch (error: any) {\n          // Log unexpected errors but don't fail the search\n          if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') {\n            logger.debug(`Error searching ${type} directory for content detection`, { \n              name,\n              type,\n              error: error?.message || String(error),\n              code: error?.code \n            });\n          }\n          // Return null instead of throwing to let other searches continue\n          return null;\n        }\n      });\n\n      // PERFORMANCE OPTIMIZATION (Task #9): Define exact match criteria\n      const isExactMatch = (match: ElementDetectionMatch): boolean => {\n        const filename = path.basename(match.path, path.extname(match.path));\n        return filename.toLowerCase() === name.toLowerCase();\n      };\n\n      // Execute searches with early termination optimization\n      const searchResults = await EarlyTerminationSearch.executeWithEarlyTermination(\n        searchFunctions,\n        isExactMatch,\n        {\n          operationName: 'element-type-detection',\n          timeoutAfterExactMatch: 1000, // Wait 1 second for other searches after exact match\n          maxParallelSearches: 8 // Limit concurrent searches to avoid overwhelming the system\n        }\n      );\n\n      // PERFORMANCE OPTIMIZATION (Task #8): Enhanced batch operation reporting\n      const batchResults = {\n        name,\n        totalSearches: searchResults.totalSearches,\n        completedSearches: searchResults.completedSearches,\n        matches: searchResults.matches.length,\n        failures: searchResults.failures.length,\n        exactMatchFound: !!searchResults.exactMatch,\n        exactMatchType: searchResults.exactMatch?.type,\n        earlyTerminationTriggered: searchResults.earlyTerminationTriggered,\n        performanceGain: searchResults.performanceGain,\n        matchedTypes: searchResults.matches.map(m => m.type),\n        failedTypes: searchResults.failures.map(f => elementTypes[f.index]).filter(Boolean)\n      };\n\n      logger.debug('Element type detection completed with early termination optimization', batchResults);\n\n      // PERFORMANCE OPTIMIZATION (Task #8): Clear reporting of partial failures\n      if (searchResults.failures.length > 0) {\n        logger.warn('Some element type searches failed during batch operation', {\n          name,\n          failures: searchResults.failures.map(f => ({\n            type: elementTypes[f.index] || 'unknown',\n            error: f.error.substring(0, 100) // Truncate long error messages\n          })),\n          successRate: `${searchResults.completedSearches}/${searchResults.totalSearches}`,\n          impactOnResults: searchResults.matches.length > 0 \n            ? 'No impact - matches found in successful searches' \n            : 'Potential impact - no matches found'\n        });\n\n        // If we have failures and no matches, provide actionable guidance\n        if (searchResults.matches.length === 0 && searchResults.failures.length > 0) {\n          logger.warn('Batch operation had failures and no matches found', {\n            name,\n            recommendation: 'Consider checking file permissions or portfolio structure',\n            failureCount: searchResults.failures.length,\n            totalSearches: searchResults.totalSearches\n          });\n        }\n      }\n\n      // Log performance gains from early termination\n      if (searchResults.earlyTerminationTriggered) {\n        logger.info('Early termination optimization applied successfully', {\n          name,\n          exactMatchType: searchResults.exactMatch?.type,\n          performanceGain: searchResults.performanceGain,\n          searchesCompleted: searchResults.completedSearches,\n          searchesTotal: searchResults.totalSearches\n        });\n      }\n\n      return {\n        found: searchResults.matches.length > 0,\n        matches: searchResults.matches\n      };\n\n    } catch (error) {\n      logger.error('Error in element type detection', {\n        name,\n        error: error instanceof Error ? error.message : String(error)\n      });\n      \n      // Return empty result on detection failure\n      return {\n        found: false,\n        matches: []\n      };\n    }\n  }\n\n  /**\n   * UX IMPROVEMENT: Generate name suggestions for similar content\n   * PERFORMANCE OPTIMIZATION (Task #8): Enhanced batch operation handling with clear partial failure reporting\n   * Helps users find content when exact matches fail\n   */\n  private async generateNameSuggestions(searchName: string): Promise<Array<{name: string, type: string}>> {\n    try {\n      const suggestions: Array<{name: string, type: string}> = [];\n      const searchLower = searchName.toLowerCase();\n      const elementTypes = Object.values(ElementType);\n      \n      // Track batch operation results for better diagnostics\n      const batchResults = {\n        searchName,\n        totalTypes: elementTypes.length,\n        successfulScans: 0,\n        failedScans: 0,\n        failureDetails: [] as Array<{ type: ElementType; error: string }>,\n        totalSuggestions: 0,\n        suggestionsByType: {} as Record<string, number>\n      };\n      \n      // Process all element types for suggestions\n      for (const elementType of elementTypes) {\n        try {\n          const portfolioManager = PortfolioManager.getInstance();\n          const elementDir = portfolioManager.getElementDir(elementType);\n          \n          // Get files in this directory\n          const files = await FileDiscoveryUtil.findFile(elementDir, '*', {\n            extensions: ['.md', '.json', '.yaml', '.yml'],\n            partialMatch: false,\n            cacheResults: true\n          });\n          \n          let typeSuggestions = 0;\n          \n          if (Array.isArray(files)) {\n            for (const filePath of files) {\n              const basename = path.basename(filePath, path.extname(filePath));\n              \n              // Calculate similarity using simple metrics\n              if (this.calculateSimilarity(searchLower, basename.toLowerCase()) > SEARCH_CONFIG.MIN_SIMILARITY_SCORE) {\n                suggestions.push({\n                  name: basename,\n                  type: elementType\n                });\n                typeSuggestions++;\n              }\n            }\n          } else if (files) {\n            const basename = path.basename(files, path.extname(files));\n            if (this.calculateSimilarity(searchLower, basename.toLowerCase()) > SEARCH_CONFIG.MIN_SIMILARITY_SCORE) {\n              suggestions.push({\n                name: basename,\n                type: elementType\n              });\n              typeSuggestions++;\n            }\n          }\n          \n          batchResults.successfulScans++;\n          batchResults.suggestionsByType[elementType] = typeSuggestions;\n          \n        } catch (error) {\n          // PERFORMANCE OPTIMIZATION (Task #8): Track and report partial failures\n          batchResults.failedScans++;\n          batchResults.failureDetails.push({\n            type: elementType,\n            error: error instanceof Error ? error.message : String(error)\n          });\n          \n          // Log individual failures for diagnostics\n          logger.debug('Failed to scan element type for suggestions', {\n            elementType,\n            searchName,\n            error: error instanceof Error ? error.message : String(error)\n          });\n        }\n      }\n      \n      batchResults.totalSuggestions = suggestions.length;\n      \n      // PERFORMANCE OPTIMIZATION (Task #8): Comprehensive batch operation reporting\n      logger.debug('Name suggestion batch operation completed', {\n        ...batchResults,\n        successRate: `${batchResults.successfulScans}/${batchResults.totalTypes}`,\n        // Don't log full failure details at debug level to avoid spam\n        hasFailures: batchResults.failedScans > 0\n      });\n      \n      // Report failures clearly if they occurred\n      if (batchResults.failedScans > 0) {\n        logger.warn('Some element type scans failed during name suggestion generation', {\n          searchName,\n          failedTypes: batchResults.failureDetails.map(f => f.type),\n          successfulTypes: batchResults.successfulScans,\n          impactOnResults: batchResults.totalSuggestions > 0 \n            ? 'Partial impact - suggestions found from successful scans' \n            : 'Potential impact - no suggestions generated',\n          recommendation: batchResults.totalSuggestions === 0 && batchResults.failedScans > 0\n            ? 'Check portfolio directory structure and file permissions'\n            : 'Suggestion generation partially successful despite some failures'\n        });\n      }\n      \n      // Sort by similarity (higher is better) and return top suggestions\n      const sortedSuggestions = suggestions.sort((a, b) => {\n        const simA = this.calculateSimilarity(searchLower, a.name.toLowerCase());\n        const simB = this.calculateSimilarity(searchLower, b.name.toLowerCase());\n        return simB - simA;\n      });\n      \n      logger.debug('Name suggestions generated successfully', {\n        searchName,\n        totalSuggestions: sortedSuggestions.length,\n        topSuggestions: sortedSuggestions.slice(0, 3).map(s => s.name)\n      });\n      \n      return sortedSuggestions;\n      \n    } catch (error) {\n      logger.warn('Failed to generate name suggestions - batch operation failed completely', { \n        searchName, \n        error: error instanceof Error ? error.message : String(error),\n        recommendation: 'Check portfolio structure and permissions'\n      });\n      return [];\n    }\n  }\n  \n  /**\n   * Simple similarity calculation using Levenshtein-like approach\n   * Returns value between 0 and 1, where 1 is identical\n   */\n  private calculateSimilarity(str1: string, str2: string): number {\n    // Handle exact matches\n    if (str1 === str2) return 1;\n    \n    // Handle substring matches\n    if (str1.includes(str2) || str2.includes(str1)) return 0.8;\n    \n    // Handle partial matches\n    const longer = str1.length > str2.length ? str1 : str2;\n    const shorter = str1.length > str2.length ? str2 : str1;\n    \n    if (longer.length === 0) return 0;\n    \n    // Count common characters\n    let common = 0;\n    for (let i = 0; i < shorter.length; i++) {\n      if (longer.includes(shorter[i])) {\n        common++;\n      }\n    }\n    \n    return common / longer.length;\n  }\n  \n  /**\n   * UX IMPROVEMENT: Save element with automatic retry logic for transient failures\n   * Handles common GitHub API issues like rate limits and temporary network problems\n   */\n  private async saveElementWithRetry(\n    adapter: PortfolioElementAdapter, \n    elementName: string, \n    elementType: ElementType,\n    maxRetries: number = RETRY_CONFIG.MAX_ATTEMPTS\n  ): Promise<string | null> {\n    let lastError: any = null;\n    \n    for (let attempt = 1; attempt <= maxRetries; attempt++) {\n      try {\n        logger.debug(`Attempting to save element (attempt ${attempt}/${maxRetries})`, {\n          elementName,\n          elementType,\n          attempt\n        });\n        \n        const fileUrl = await this.portfolioManager.saveElement(adapter, true);\n        \n        if (fileUrl) {\n          if (attempt > 1) {\n            logger.info(`Element saved successfully after ${attempt} attempts`, {\n              elementName,\n              elementType,\n              fileUrl\n            });\n          }\n          return fileUrl;\n        }\n        \n        // If saveElement returns null, treat as a failure but don't retry immediately\n        lastError = new Error(`saveElement returned null on attempt ${attempt}`);\n        \n      } catch (error: any) {\n        lastError = error;\n        const isRetryable = this.isRetryableError(error);\n        \n        logger.warn(`Save attempt ${attempt} failed`, {\n          elementName,\n          elementType,\n          attempt,\n          error: error.message,\n          isRetryable,\n          willRetry: isRetryable && attempt < maxRetries\n        });\n        \n        // If this is not a retryable error, fail immediately\n        if (!isRetryable) {\n          logger.error('Non-retryable error encountered, aborting retries', {\n            elementName,\n            error: error.message\n          });\n          break;\n        }\n        \n        // If we have more attempts, wait before retrying\n        if (attempt < maxRetries) {\n          const delay = calculateRetryDelay(attempt);\n          logger.debug(`Waiting ${delay}ms before retry`, { attempt, delay });\n          await new Promise(resolve => setTimeout(resolve, delay));\n        }\n      }\n    }\n    \n    // All attempts failed\n    logger.error(`All ${maxRetries} save attempts failed`, {\n      elementName,\n      elementType,\n      lastError: lastError?.message\n    });\n    \n    return null;\n  }\n  \n  /**\n   * Determine if an error is worth retrying\n   * Retryable: network issues, rate limits, temporary GitHub API problems\n   * Non-retryable: authentication issues, validation errors, permanent failures\n   */\n  private isRetryableError(error: any): boolean {\n    const errorMessage = error?.message?.toLowerCase() || '';\n    const errorCode = error?.code;\n    const statusCode = error?.status || error?.statusCode;\n    \n    // Network and timeout errors\n    if (errorCode === 'ENOTFOUND' || errorCode === 'ECONNRESET' || errorCode === 'ETIMEDOUT') {\n      return true;\n    }\n    \n    // GitHub API rate limits\n    if (statusCode === 429 || errorMessage.includes('rate limit')) {\n      return true;\n    }\n    \n    // Temporary GitHub API issues\n    if (statusCode >= 500 && statusCode < 600) {\n      return true;\n    }\n    \n    // Temporary GitHub API problems\n    if (errorMessage.includes('temporarily unavailable') || \n        errorMessage.includes('service unavailable') ||\n        errorMessage.includes('internal server error')) {\n      return true;\n    }\n    \n    // Connection issues\n    if (errorMessage.includes('connection') && \n        (errorMessage.includes('timeout') || errorMessage.includes('reset'))) {\n      return true;\n    }\n    \n    // Don't retry authentication or permission issues\n    if (statusCode === 401 || statusCode === 403 || \n        errorMessage.includes('unauthorized') || \n        errorMessage.includes('forbidden') ||\n        errorMessage.includes('authentication')) {\n      return false;\n    }\n    \n    // Don't retry validation errors\n    if (statusCode === 400 || statusCode === 422 ||\n        errorMessage.includes('invalid') ||\n        errorMessage.includes('validation')) {\n      return false;\n    }\n    \n    // Default to not retrying for unknown errors to avoid infinite loops\n    return false;\n  }\n}"]}