@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/workflow-orchestrator.js

@@ -0,0 +1,2131 @@
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, extname, join } from 'node:path';
+import { logInfo, logWarn } from '@repo/shared/logs';
+import { safeThrowIfAborted } from './abort-support';
+import { BatchProcessorEngine } from './batch-processor';
+import { runWithContext } from './context';
+import { getGlobalMemoryMonitor } from './memory-monitor';
+import { getSessionRecoveryManager } from './session-recovery';
+import { enhancedClone, isStructuredCloneAvailable } from './structured-clone';
+import { ok, runTool } from './tool-helpers';
+import { validateFilePath, validateSessionId } from './validation';
+import { worktreeManagerTool } from './worktree-manager';
+const SESSION_CONTEXTS = new Map();
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function asBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = [];
+    for (const item of value) {
+        if (typeof item !== 'string')
+            return undefined;
+        strings.push(item);
+    }
+    return strings;
+}
+function parseFirstContentJson(response) {
+    const first = response.content[0];
+    if (!first)
+        return {};
+    try {
+        return JSON.parse(first.text);
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeSessionCheckpointErrors(value) {
+    if (!Array.isArray(value))
+        return [];
+    const errors = [];
+    for (const item of value) {
+        const record = asRecord(item);
+        if (!record)
+            continue;
+        const file = asString(record['file']);
+        const error = asString(record['error']);
+        const timestamp = asNumber(record['timestamp']);
+        if (!file || !error || timestamp === undefined)
+            continue;
+        errors.push({ file, error, timestamp });
+    }
+    return errors;
+}
+function isAnalysisContext(value) {
+    const record = asRecord(value);
+    if (!record)
+        return false;
+    return (typeof record['packagePath'] === 'string' &&
+        typeof record['isWorktree'] === 'boolean' &&
+        typeof record['isVercelProject'] === 'boolean' &&
+        typeof record['hasNextJs'] === 'boolean' &&
+        typeof record['hasTypeScript'] === 'boolean');
+}
+export const workflowOrchestratorTool = {
+    name: 'workflow_orchestrator',
+    description: 'Orchestrates code quality analysis workflows replacing 27 core functions',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'detectWorktree',
+                    'setupContext',
+                    'createSession',
+                    'checkMCPAvailability',
+                    'prepareExecutionContext',
+                    'storeExecutionContext',
+                    'getExecutionContext',
+                    'validateMainAgentContext',
+                    'detectCallContext',
+                    'confirmInBranchRisks',
+                    'createBackupBranch',
+                    'validateBranchStrategy',
+                    'executeBackupPlan',
+                    'discoverFiles',
+                    'countWordTargets',
+                    'detectPatterns',
+                    'removeWords',
+                    'centralizeMocks',
+                    'modernizeES2023',
+                    'analyzeUtilization',
+                    'generateDependencyIndex',
+                    'runModernization',
+                    'checkMemoryPressure',
+                    'performCleanup',
+                    'getUserConfirmation',
+                    'completeAnalysis',
+                    'logToFile',
+                    'contextualAnalysis',
+                    'safeWorkflow',
+                    'branchAwareExecution',
+                    'sessionManagedWorkflow',
+                    'streamFileDiscovery',
+                    'incrementalAnalysis',
+                    'loadAnalysisCheckpoint',
+                    'saveAnalysisCheckpoint',
+                    'resumeAnalysis',
+                    'streamBatchProcessing',
+                ],
+                description: 'Workflow action to perform',
+            },
+            packagePath: {
+                type: 'string',
+                description: 'Path to the package being analyzed',
+            },
+            sessionId: {
+                type: 'string',
+                description: 'Unique session identifier',
+            },
+            userMessage: {
+                type: 'string',
+                description: 'Original user message/request',
+            },
+            options: {
+                type: 'object',
+                description: 'Configuration options for the workflow',
+            },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Array of file paths for processing',
+            },
+            analysisData: {
+                type: 'object',
+                description: 'Analysis results data',
+            },
+            context: {
+                type: 'object',
+                description: 'Analysis context information',
+            },
+            agentType: {
+                type: 'string',
+                enum: ['main', 'subagent'],
+                description: 'Type of agent making the call',
+            },
+            enforceWorktreeOnly: {
+                type: 'boolean',
+                description: 'Whether to enforce worktree-only policy',
+            },
+            operation: {
+                type: 'string',
+                description: 'Operation being performed for risk assessment',
+            },
+            riskLevel: {
+                type: 'string',
+                enum: ['low', 'medium', 'high', 'critical'],
+                description: 'Risk level of the operation',
+            },
+            agentName: {
+                type: 'string',
+                description: 'Name of the agent for backup branch creation',
+            },
+            affectedFiles: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Files that will be affected by the operation',
+            },
+            calledDirectly: {
+                type: 'boolean',
+                description: 'Whether the agent was called directly via Task tool',
+            },
+            userRequestedInBranch: {
+                type: 'boolean',
+                description: 'Whether user explicitly requested in-branch operation',
+            },
+            workingDirectory: {
+                type: 'string',
+                description: 'Preferred working directory (worktree path)',
+            },
+            signal: {
+                description: 'AbortSignal for cancelling the operation',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        return runTool('workflow_orchestrator', args.action, async () => {
+            const { action, packagePath, sessionId, userMessage, options, files, analysisData, context, agentType, enforceWorktreeOnly, operation, riskLevel, agentName, affectedFiles, calledDirectly, userRequestedInBranch, workingDirectory, signal, } = args;
+            if (sessionId) {
+                const sessionValidation = validateSessionId(sessionId);
+                if (!sessionValidation.isValid) {
+                    throw new Error(`Invalid session ID: ${sessionValidation.error}`);
+                }
+            }
+            if (packagePath) {
+                const pathValidation = validateFilePath(packagePath, [process.cwd()]);
+                if (!pathValidation.isValid) {
+                    throw new Error(`Invalid package path: ${pathValidation.error}`);
+                }
+            }
+            safeThrowIfAborted(signal);
+            switch (action) {
+                case 'validateMainAgentContext': {
+                    const result = await runWithContext({
+                        toolName: 'workflow_orchestrator',
+                        metadata: { action: 'validateMainAgentContext', agentType, enforceWorktreeOnly },
+                    }, async () => {
+                        return await validateMainAgentContext(agentType, enforceWorktreeOnly, packagePath, signal);
+                    });
+                    return ok(result);
+                }
+                case 'detectCallContext': {
+                    const callContext = await detectCallContext(agentType, sessionId);
+                    return ok(callContext);
+                }
+                case 'confirmInBranchRisks': {
+                    if (!operation || !riskLevel) {
+                        throw new Error('Operation and risk level required for risk confirmation');
+                    }
+                    const confirmation = await confirmInBranchRisks(operation, riskLevel, affectedFiles ?? [], userRequestedInBranch);
+                    return ok(confirmation);
+                }
+                case 'createBackupBranch': {
+                    if (!agentName || !operation) {
+                        throw new Error('Agent name and operation required for backup branch creation');
+                    }
+                    const backup = await createBackupBranch(agentName, operation, packagePath);
+                    return ok(backup);
+                }
+                case 'validateBranchStrategy': {
+                    if (!operation) {
+                        throw new Error('Operation required for branch strategy validation');
+                    }
+                    const validation = await validateBranchStrategy(operation, agentType, calledDirectly, userRequestedInBranch);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(validation),
+                            },
+                        ],
+                    };
+                }
+                case 'detectWorktree': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for worktree detection');
+                    }
+                    const result = await detectIfInWorktree(packagePath);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    isWorktree: result.isWorktree,
+                                    worktreePath: result.worktreePath,
+                                    originalPath: result.originalPath,
+                                    branchName: result.branchName,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'setupContext': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for context setup');
+                    }
+                    const skipWorktreeDetection = asBoolean(options?.skipWorktreeDetection) ?? false;
+                    const context = await setupAnalysisContext(packagePath, skipWorktreeDetection);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(context),
+                            },
+                        ],
+                    };
+                }
+                case 'createSession': {
+                    if (!packagePath || !sessionId) {
+                        throw new Error('Package path and session ID required for session creation');
+                    }
+                    const session = await createOrResumeSession(userMessage ?? '', {
+                        packagePath,
+                        sessionId,
+                        options: options ?? {},
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(session),
+                            },
+                        ],
+                    };
+                }
+                case 'checkMCPAvailability': {
+                    const availability = await checkMCPToolAvailability();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(availability),
+                            },
+                        ],
+                    };
+                }
+                case 'prepareExecutionContext': {
+                    const isMain = agentType === 'main';
+                    if (isMain) {
+                        const branch = `agent/quality-${(sessionId ?? 'session').slice(0, 12)}`;
+                        const baseBranch = options?.baseBranch ?? 'main';
+                        const targetDirectory = options?.targetDirectory || `/tmp/worktree-${(sessionId ?? 'session').slice(0, 8)}`;
+                        const created = await worktreeManagerTool.execute({
+                            action: 'createAnalysisWorktree',
+                            repositoryPath: packagePath ?? '.',
+                            worktreeName: `analysis-${(sessionId ?? 'session').slice(0, 8)}`,
+                            branchName: baseBranch,
+                            baseBranch,
+                            targetDirectory,
+                            sessionId,
+                        });
+                        const branched = await worktreeManagerTool.execute({
+                            action: 'createWorktreeBranch',
+                            targetDirectory,
+                            branchName: branch,
+                            baseBranch,
+                            sessionId,
+                        });
+                        const switched = await worktreeManagerTool.execute({
+                            action: 'switchWorktreeBranch',
+                            targetDirectory,
+                            branchName: branch,
+                            sessionId,
+                        });
+                        const contextPayload = {
+                            worktreePath: targetDirectory,
+                            ephemeralBranch: branch,
+                            baseBranch,
+                        };
+                        if (sessionId) {
+                            SESSION_CONTEXTS.set(sessionId, contextPayload);
+                        }
+                        return ok({
+                            mode: 'worktree',
+                            worktree: { baseBranch, branch, targetDirectory },
+                            created,
+                            branched,
+                            switched,
+                            context: contextPayload,
+                            message: 'Worktree and ephemeral branch prepared for main agent execution',
+                        });
+                    }
+                    const mutating = options?.mutating === true;
+                    const allowInBranch = options?.allowInBranch === true;
+                    if (mutating && !allowInBranch) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        mode: 'in-branch',
+                                        allowed: false,
+                                        reason: 'Mutating operation requires options.allowInBranch=true',
+                                    }),
+                                },
+                            ],
+                        };
+                    }
+                    const backupBranch = `backup/${agentName ?? 'subagent'}-${Date.now()}`;
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    mode: 'in-branch',
+                                    allowed: true,
+                                    backup: mutating
+                                        ? {
+                                            required: true,
+                                            branch: backupBranch,
+                                            plan: [
+                                                `git checkout -b ${backupBranch}`,
+                                                'git add -A',
+                                                `git commit -m "Backup before ${agentName ?? 'subagent'} operation"`,
+                                            ],
+                                        }
+                                        : { required: false },
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'storeExecutionContext': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for storing execution context');
+                    }
+                    const ctx = {
+                        worktreePath: asString(options?.worktreePath) ?? asString(options?.targetDirectory) ?? undefined,
+                        ephemeralBranch: asString(options?.ephemeralBranch),
+                        baseBranch: asString(options?.baseBranch) ?? 'main',
+                    };
+                    SESSION_CONTEXTS.set(sessionId, ctx);
+                    return ok({ stored: true, sessionId, context: ctx });
+                }
+                case 'getExecutionContext': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for retrieving execution context');
+                    }
+                    const ctx = SESSION_CONTEXTS.get(sessionId) ?? null;
+                    return ok({ sessionId, context: ctx });
+                }
+                case 'executeBackupPlan': {
+                    const targetDir = asString(args.workingDirectory) ?? packagePath ?? process.cwd();
+                    const backup = await worktreeManagerTool.execute({
+                        action: 'backupWorktreeState',
+                        targetDirectory: targetDir,
+                        sessionId,
+                    });
+                    return ok({ executed: true, backup });
+                }
+                case 'discoverFiles': {
+                    if (!packagePath || !context) {
+                        throw new Error('Package path and context required for file discovery');
+                    }
+                    if (!isAnalysisContext(context)) {
+                        throw new Error('Invalid analysis context for file discovery');
+                    }
+                    const discoveredFiles = await discoverProjectFiles(packagePath, context, sessionId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(discoveredFiles),
+                            },
+                        ],
+                    };
+                }
+                case 'countWordTargets': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for word target counting');
+                    }
+                    const wordTargets = await countWordRemovalTargets(packagePath);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(wordTargets),
+                            },
+                        ],
+                    };
+                }
+                case 'detectPatterns': {
+                    if (!context || !files) {
+                        throw new Error('Context and files required for pattern detection');
+                    }
+                    if (!isAnalysisContext(context)) {
+                        throw new Error('Invalid analysis context for pattern detection');
+                    }
+                    const patterns = await detectArchitecturalPatterns(context, files);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(patterns),
+                            },
+                        ],
+                    };
+                }
+                case 'checkMemoryPressure': {
+                    const memoryInfo = getMemoryUsage();
+                    const highPressure = isMemoryPressureHigh();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    memoryUsage: memoryInfo,
+                                    highPressure,
+                                    recommendations: highPressure ? ['Perform cleanup', 'Reduce batch size'] : [],
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'performCleanup': {
+                    const cleanupResult = await performMemoryCleanup();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(cleanupResult),
+                            },
+                        ],
+                    };
+                }
+                case 'getUserConfirmation': {
+                    const confirmation = await getUserConfirmation();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    approved: confirmation,
+                                    message: 'Auto-approved in non-interactive mode',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'logToFile': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for logging');
+                    }
+                    const logResult = await logToFile(userMessage ?? 'Workflow action executed', sessionId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(logResult),
+                            },
+                        ],
+                    };
+                }
+                case 'completeAnalysis': {
+                    if (!context || !sessionId) {
+                        throw new Error('Context and session ID required for analysis completion');
+                    }
+                    if (!isAnalysisContext(context)) {
+                        throw new Error('Invalid analysis context for analysis completion');
+                    }
+                    const completionResult = await completeAnalysisWorkflow(context, sessionId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(completionResult),
+                            },
+                        ],
+                    };
+                }
+                case 'removeWords':
+                case 'centralizeMocks':
+                case 'modernizeES2023':
+                case 'analyzeUtilization':
+                case 'generateDependencyIndex':
+                case 'runModernization': {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    action,
+                                    status: 'pending_implementation',
+                                    message: `${action} will be implemented in Phase 2 - delegating to specialized MCP tools`,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'contextualAnalysis': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for contextual analysis');
+                    }
+                    const contextualResult = await performContextualAnalysis(packagePath, agentType, sessionId, options ?? {}, signal);
+                    return ok(contextualResult);
+                }
+                case 'safeWorkflow': {
+                    if (!operation || !packagePath) {
+                        throw new Error('Operation and package path required for safe workflow');
+                    }
+                    const safeResult = await performSafeWorkflow(operation, packagePath, agentType, riskLevel ?? 'medium', sessionId, signal);
+                    return ok(safeResult);
+                }
+                case 'branchAwareExecution': {
+                    if (!operation || !packagePath) {
+                        throw new Error('Operation and package path required for branch-aware execution');
+                    }
+                    const branchResult = await performBranchAwareExecution(operation, packagePath, agentType, affectedFiles ?? [], sessionId, signal);
+                    return ok(branchResult);
+                }
+                case 'sessionManagedWorkflow': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for session-managed workflow');
+                    }
+                    const sessionResult = await performSessionManagedWorkflow(packagePath, options ?? {}, sessionId, signal);
+                    return ok(sessionResult);
+                }
+                case 'streamFileDiscovery': {
+                    if (!packagePath) {
+                        throw new Error('Package path required for streaming file discovery');
+                    }
+                    const streamResult = await streamFileDiscovery(packagePath, options ?? {}, sessionId, signal);
+                    return ok(streamResult);
+                }
+                case 'incrementalAnalysis': {
+                    if (!packagePath || !files) {
+                        throw new Error('Package path and files required for incremental analysis');
+                    }
+                    const incrementalResult = await performIncrementalAnalysis(packagePath, files, options ?? {}, sessionId, signal);
+                    return ok(incrementalResult);
+                }
+                case 'loadAnalysisCheckpoint': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for loading checkpoint');
+                    }
+                    const checkpointId = asString(options?.checkpointId);
+                    const checkpoint = await loadAnalysisCheckpoint(sessionId, checkpointId);
+                    return ok(checkpoint);
+                }
+                case 'saveAnalysisCheckpoint': {
+                    if (!sessionId || !analysisData) {
+                        throw new Error('Session ID and analysis data required for saving checkpoint');
+                    }
+                    const savedCheckpoint = await saveAnalysisCheckpoint(sessionId, analysisData, packagePath, options ?? {});
+                    return ok(savedCheckpoint);
+                }
+                case 'resumeAnalysis': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for resuming analysis');
+                    }
+                    const checkpointId = asString(options?.checkpointId);
+                    const resumeResult = await resumeAnalysisFromCheckpoint(sessionId, checkpointId, signal);
+                    return ok(resumeResult);
+                }
+                case 'streamBatchProcessing': {
+                    if (!files) {
+                        throw new Error('Files required for stream batch processing');
+                    }
+                    const batchResult = await performStreamBatchProcessing(files, options ?? {}, sessionId, signal);
+                    return ok(batchResult);
+                }
+                case 'saveProgressCheckpoint': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for saving progress checkpoint');
+                    }
+                    const progressResult = await saveProgressToCheckpoint(sessionId, options ?? {}, packagePath, workingDirectory, signal);
+                    return ok(progressResult);
+                }
+                case 'loadProgressCheckpoint': {
+                    if (!sessionId) {
+                        throw new Error('Session ID required for loading progress checkpoint');
+                    }
+                    const loadResult = await loadProgressFromCheckpoint(sessionId, options ?? {}, signal);
+                    return ok(loadResult);
+                }
+                case 'listRecoverableSessions': {
+                    const sessionDir = asString(options?.sessionDir);
+                    const sessionsList = await listAllRecoverableSessions(sessionDir, signal);
+                    return ok(sessionsList);
+                }
+                default:
+                    throw new Error(`Unknown workflow action: ${action}`);
+            }
+        });
+    },
+};
+async function detectIfInWorktree(packagePath, signal) {
+    try {
+        safeThrowIfAborted(signal);
+        return {
+            isWorktree: packagePath.includes('/.git/worktrees/') || packagePath.includes('worktree'),
+            worktreePath: packagePath,
+            originalPath: packagePath,
+            branchName: 'main',
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('aborted')) {
+            throw error;
+        }
+        return {
+            isWorktree: false,
+            worktreePath: packagePath,
+            originalPath: packagePath,
+            branchName: 'unknown',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+async function setupAnalysisContext(packagePath, skipWorktreeDetection = false, signal) {
+    const context = {
+        packagePath,
+        isWorktree: false,
+        isVercelProject: false,
+        hasNextJs: false,
+        hasTypeScript: false,
+    };
+    try {
+        safeThrowIfAborted(signal);
+        if (!skipWorktreeDetection) {
+            const worktreeInfo = await detectIfInWorktree(packagePath, signal);
+            context.isWorktree = worktreeInfo.isWorktree;
+        }
+        safeThrowIfAborted(signal);
+        try {
+            await fs.access(join(packagePath, 'tsconfig.json'));
+            context.hasTypeScript = true;
+        }
+        catch {
+            context.hasTypeScript = false;
+        }
+        context.hasNextJs = packagePath.includes('nextjs') || packagePath.includes('next');
+        try {
+            await fs.access(join(packagePath, 'vercel.json'));
+            context.isVercelProject = true;
+        }
+        catch {
+            try {
+                await fs.access(join(packagePath, '.vercel'));
+                context.isVercelProject = true;
+            }
+            catch {
+                context.isVercelProject = false;
+            }
+        }
+        return context;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('aborted')) {
+            throw error;
+        }
+        return context;
+    }
+}
+async function createOrResumeSession(userMessage, config) {
+    const sessionId = config.sessionId || `session-${crypto.randomUUID().substring(0, 8)}`;
+    const sessionData = {
+        sessionId,
+        startTime: Date.now(),
+        packagePath: config.packagePath,
+        options: config.options ?? {},
+        context: await setupAnalysisContext(config.packagePath),
+    };
+    return isStructuredCloneAvailable()
+        ? enhancedClone(sessionData, { fallbackToJson: false }).data
+        : sessionData;
+}
+async function checkMCPToolAvailability() {
+    return {
+        available: [
+            'memory_monitor',
+            'path_manager',
+            'architecture_detector',
+            'batch_processor',
+            'file_discovery',
+            'security_scanner',
+            'test_runner',
+            'report_generator',
+            'code_analysis',
+            'worktree_manager',
+            'context_session_manager',
+            'pattern_analyzer',
+            'optimization_engine',
+            'dependency_analyzer',
+        ],
+        unavailable: [],
+    };
+}
+async function discoverProjectFiles(packagePath, context, sessionId) {
+    return {
+        totalFiles: 0,
+        sourceFiles: [],
+        testFiles: [],
+        configFiles: [],
+    };
+}
+async function countWordRemovalTargets(packagePath) {
+    return {
+        totalTargets: 0,
+        byWord: {},
+        affectedFiles: [],
+    };
+}
+async function detectArchitecturalPatterns(context, files) {
+    return {
+        frameworks: [],
+        patterns: [],
+        antiPatterns: [],
+        recommendations: [
+            {
+                description: 'Consider using architectural patterns for better code organization',
+                priority: 2,
+            },
+        ],
+        detectedFramework: 'generic',
+    };
+}
+function getMemoryUsage() {
+    if (typeof process !== 'undefined' && process.memoryUsage) {
+        const usage = process.memoryUsage();
+        return {
+            heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
+            heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
+            external: Math.round(usage.external / 1024 / 1024),
+            rss: Math.round(usage.rss / 1024 / 1024),
+            heapUtilization: Math.round((usage.heapUsed / usage.heapTotal) * 100),
+        };
+    }
+    return {
+        heapUsed: 0,
+        heapTotal: 0,
+        external: 0,
+        rss: 0,
+        heapUtilization: 0,
+    };
+}
+function isMemoryPressureHigh() {
+    const usage = getMemoryUsage();
+    const HIGH_MEMORY_THRESHOLD = 3000;
+    const HIGH_UTILIZATION_THRESHOLD = 85;
+    return (usage.heapUsed > HIGH_MEMORY_THRESHOLD || usage.heapUtilization > HIGH_UTILIZATION_THRESHOLD);
+}
+async function performMemoryCleanup() {
+    const memoryBefore = getMemoryUsage();
+    if (typeof global !== 'undefined' && global.gc) {
+        global.gc();
+    }
+    const memoryAfter = getMemoryUsage();
+    return {
+        memoryBefore,
+        memoryAfter,
+        cleaned: memoryBefore.heapUsed - memoryAfter.heapUsed,
+    };
+}
+async function getUserConfirmation() {
+    return true;
+}
+async function logToFile(message, sessionId) {
+    return {
+        logged: true,
+        sessionId,
+        message,
+        timestamp: new Date().toISOString(),
+    };
+}
+async function completeAnalysisWorkflow(context, sessionId) {
+    return {
+        sessionId,
+        completedAt: new Date().toISOString(),
+        context,
+        status: 'completed',
+    };
+}
+async function validateMainAgentContext(agentType, enforceWorktreeOnly, packagePath, signal) {
+    safeThrowIfAborted(signal);
+    if (agentType === 'main' && enforceWorktreeOnly) {
+        await detectIfInWorktree(packagePath ?? '.', signal);
+        return {
+            valid: true,
+            agentType: 'main',
+            enforceWorktreeOnly: true,
+            policy: 'WORKTREE_ONLY_ABSOLUTE',
+            message: 'Main agent will create worktree for safe isolation',
+            worktreeRequired: true,
+        };
+    }
+    return {
+        valid: true,
+        agentType: agentType ?? 'unknown',
+        enforceWorktreeOnly: false,
+        policy: 'FLEXIBLE',
+        message: 'Subagent with flexible branch strategy',
+    };
+}
+async function detectCallContext(agentType, sessionId) {
+    const stack = new Error().stack ?? '';
+    const stackLines = stack.split('\n');
+    const calledFromClaude = stackLines.some(line => line.includes('claude-code-agent'));
+    const calledFromTask = stackLines.some(line => line.includes('Task') || line.includes('agent-router'));
+    const calledFromScript = stackLines.some(line => line.includes('.mjs') || line.includes('script'));
+    const executionContext = {
+        isScriptExecution: calledFromScript,
+        isTaskExecution: calledFromTask,
+        isDirectCall: !calledFromClaude && !calledFromTask,
+        hasParentAgent: agentType === 'main',
+    };
+    return {
+        calledByMainAgent: agentType === 'main',
+        directCall: agentType !== 'main' && !calledFromTask,
+        sessionId: sessionId || `ctx_${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        contextType: agentType === 'main'
+            ? 'main_agent_orchestration'
+            : calledFromTask
+                ? 'subagent_task_execution'
+                : 'direct_subagent_call',
+        executionContext,
+        callStack: stackLines.slice(0, 5).map(line => line.trim()),
+    };
+}
+async function confirmInBranchRisks(operation, riskLevel, affectedFiles, userRequestedInBranch) {
+    const RISK_MESSAGES = {
+        low: 'Low risk operation - primarily documentation or reporting changes',
+        medium: 'Medium risk operation - may affect configuration or non-critical files',
+        high: 'High risk operation - modifies source code, could break compilation',
+        critical: 'Critical risk operation - affects dependencies, build system, or core architecture',
+    };
+    const riskInfo = {
+        operation,
+        riskLevel,
+        affectedFiles,
+        message: RISK_MESSAGES[riskLevel] ?? 'Unknown risk level',
+        recommendations: [],
+    };
+    if (riskLevel === 'high' || riskLevel === 'critical') {
+        riskInfo.recommendations = [
+            'Backup branch will be created automatically',
+            'Compilation validation required after changes',
+            'Rollback plan prepared in case of failure',
+            'Consider using worktree mode instead for maximum safety',
+        ];
+    }
+    const userConfirmed = userRequestedInBranch === true;
+    let confirmed;
+    const isLowRisk = riskLevel === 'low';
+    const isMediumRiskWithConsent = riskLevel === 'medium' && userConfirmed;
+    const isHighRiskWithConsent = (riskLevel === 'high' || riskLevel === 'critical') && userConfirmed;
+    if (isLowRisk) {
+        confirmed = true;
+    }
+    else if (isMediumRiskWithConsent) {
+        confirmed = true;
+    }
+    else if (isHighRiskWithConsent) {
+        confirmed = true;
+    }
+    else {
+        confirmed = false;
+    }
+    return {
+        ...riskInfo,
+        confirmed,
+        userExplicitlyRequested: userConfirmed,
+        timestamp: new Date().toISOString(),
+        warningShown: true,
+        backupRequired: riskLevel === 'high' || riskLevel === 'critical',
+        acknowledgedRisks: true,
+    };
+}
+async function createBackupBranch(agentName, operation, packagePath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const branchName = `${agentName}-backup-${timestamp}`;
+    const { exec } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const execAsync = promisify(exec);
+    let created = false;
+    try {
+        if (packagePath) {
+            process.chdir(packagePath);
+        }
+        await execAsync(`git checkout -b ${branchName}`);
+        created = true;
+    }
+    catch (error) {
+        logWarn('Failed to create backup branch', {
+            error: error instanceof Error ? error.message : 'Unknown error',
+            branchName,
+        });
+    }
+    return {
+        backupBranch: branchName,
+        created,
+        agentName,
+        operation,
+        timestamp,
+        packagePath: packagePath ?? '.',
+        commands: [
+            `git checkout -b ${branchName}`,
+            `git add -A`,
+            `git commit -m "Backup before ${agentName} ${operation} operation"`,
+        ],
+    };
+}
+async function validateBranchStrategy(operation, agentType, calledDirectly, userRequestedInBranch) {
+    const OPERATION_RISKS = {
+        security_scan: 'low',
+        report_generation: 'low',
+        test_execution: 'low',
+        code_transformation: 'high',
+        dependency_updates: 'critical',
+        mock_centralization: 'high',
+        es2023_modernization: 'high',
+    };
+    const risk = OPERATION_RISKS[operation] ?? 'medium';
+    if (agentType === 'main') {
+        return {
+            allowInBranch: false,
+            reason: 'Main agent enforces worktree-only policy',
+            recommendedMode: 'worktree',
+            riskLevel: risk,
+            safe: true,
+        };
+    }
+    if (calledDirectly && userRequestedInBranch) {
+        const allowInBranch = risk === 'low' || risk === 'medium';
+        return {
+            allowInBranch,
+            reason: allowInBranch
+                ? 'Low/medium risk operation approved for in-branch mode'
+                : 'High/critical risk operation requires worktree isolation',
+            recommendedMode: allowInBranch ? 'in-branch' : 'worktree',
+            riskLevel: risk,
+            safe: true,
+            requiresBackup: risk === 'high' || risk === 'critical',
+            requiresConfirmation: true,
+        };
+    }
+    return {
+        allowInBranch: false,
+        reason: 'Default safety mode - worktree isolation recommended',
+        recommendedMode: 'worktree',
+        riskLevel: risk,
+        safe: true,
+    };
+}
+async function performContextualAnalysis(packagePath, agentType, sessionId, options = {}, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const context = await setupAnalysisContext(packagePath, false, signal);
+        const executionContextResult = await workflowOrchestratorTool.execute({
+            action: 'prepareExecutionContext',
+            agentType: agentType ?? 'subagent',
+            packagePath,
+            calledDirectly: false,
+            signal,
+        });
+        const executionContext = asRecord(parseFirstContentJson(executionContextResult)) ?? {};
+        const session = await createOrResumeSession('', {
+            packagePath,
+            sessionId,
+            options: options ?? {},
+        });
+        const discovery = await runWithContext({ toolName: 'workflow_orchestrator', metadata: { action: 'discoverFiles' } }, () => discoverProjectFiles(packagePath, context, sessionId));
+        const patterns = await detectArchitecturalPatterns(context, discovery.sourceFiles);
+        const mcpStatus = await checkMCPToolAvailability();
+        return {
+            contextAware: true,
+            sessionId: session.sessionId,
+            context: {
+                analysis: context,
+                execution: executionContext,
+                session: session.context,
+                discovery,
+                patterns,
+                mcpStatus,
+            },
+            recommendations: [
+                ...(asBoolean(executionContext['worktreeRequired'])
+                    ? [
+                        {
+                            type: 'safety',
+                            description: 'Use worktree isolation for this analysis',
+                            priority: 1,
+                        },
+                    ]
+                    : []),
+                ...patterns.recommendations.map((rec) => ({
+                    type: 'architectural',
+                    description: rec.description,
+                    priority: rec.priority ?? 2,
+                })),
+            ],
+            nextSteps: [
+                context.isWorktree
+                    ? 'Continue in current worktree'
+                    : 'Consider creating worktree for safety',
+                `Use ${patterns.detectedFramework ?? 'generic'} specific analysis patterns`,
+                mcpStatus.available.length > 0 ? 'MCP tools ready' : 'Some MCP tools unavailable',
+            ],
+            completedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error in contextual analysis',
+            partialResults: {
+                packagePath,
+                agentType,
+                sessionId,
+            },
+        };
+    }
+}
+async function performSafeWorkflow(operation, packagePath, agentType, riskLevel = 'medium', sessionId, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const strategy = await validateBranchStrategy(operation, agentType, agentType === 'main', false);
+        let backup;
+        if (strategy.requiresBackup) {
+            backup = await createBackupBranch(agentType ?? 'workflow', operation, packagePath);
+        }
+        let confirmation;
+        if (strategy.requiresConfirmation || riskLevel === 'high' || riskLevel === 'critical') {
+            confirmation = await confirmInBranchRisks(operation, riskLevel, [], false);
+        }
+        const executionContextResult = await workflowOrchestratorTool.execute({
+            action: 'prepareExecutionContext',
+            agentType: agentType ?? 'subagent',
+            packagePath,
+            calledDirectly: strategy.recommendedMode === 'worktree',
+            signal,
+        });
+        const executionContext = asRecord(parseFirstContentJson(executionContextResult)) ?? {};
+        if (sessionId) {
+            SESSION_CONTEXTS.set(sessionId, executionContext);
+        }
+        const memoryInfo = getMemoryUsage();
+        const memoryStatus = {
+            highPressure: isMemoryPressureHigh(),
+            usage: memoryInfo,
+        };
+        return {
+            safeExecution: true,
+            sessionId,
+            operation,
+            strategy,
+            backup: backup
+                ? {
+                    created: true,
+                    branchName: backup.backupBranch,
+                    backupId: backup.timestamp,
+                }
+                : { created: false },
+            confirmation: confirmation
+                ? {
+                    confirmed: confirmation.confirmed,
+                    acknowledgedRisks: confirmation.acknowledgedRisks,
+                }
+                : { confirmed: true },
+            executionContext,
+            memoryStatus,
+            readyToExecute: strategy.safe && !memoryStatus.highPressure && (!confirmation || confirmation.confirmed),
+            safeguards: {
+                branchIsolation: strategy.recommendedMode === 'worktree',
+                backupCreated: Boolean(backup),
+                userConfirmed: !confirmation || confirmation.confirmed,
+                memoryMonitored: true,
+                contextTracked: Boolean(sessionId),
+            },
+            preparedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error in safe workflow',
+            operation,
+            riskLevel,
+            failedAt: 'preparation',
+        };
+    }
+}
+async function performBranchAwareExecution(operation, packagePath, agentType, affectedFiles = [], sessionId, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const callContext = await detectCallContext(agentType, sessionId);
+        const mainAgentValidation = await validateMainAgentContext(agentType, agentType === 'main', packagePath, signal);
+        const worktreeStatus = await detectIfInWorktree(packagePath, signal);
+        const executionMode = determineExecutionMode(agentType ?? 'subagent', callContext.calledByMainAgent, worktreeStatus.isWorktree, mainAgentValidation.worktreeRequired || false);
+        let workflowResult;
+        if (executionMode.mode === 'worktree') {
+            const worktreeResult = await worktreeManagerTool.execute({
+                action: worktreeStatus.isWorktree ? 'validateWorktreeStructure' : 'createAnalysisWorktree',
+                packagePath,
+                sessionId,
+                signal,
+            });
+            workflowResult = {
+                mode: 'worktree',
+                worktreeCreated: !worktreeStatus.isWorktree,
+                worktreeStatus: worktreeResult.content,
+            };
+        }
+        else {
+            workflowResult = {
+                mode: 'in-branch',
+                branchProtection: await createBranchProtection(operation, affectedFiles),
+                riskMitigation: await setupRiskMitigation(operation, packagePath),
+            };
+        }
+        return {
+            branchAware: true,
+            sessionId,
+            operation,
+            context: {
+                callContext,
+                mainAgentValidation,
+                worktreeStatus,
+                executionMode,
+                affectedFiles,
+            },
+            workflow: workflowResult,
+            recommendations: [
+                ...executionMode.warnings.map((warning) => ({
+                    type: 'warning',
+                    description: warning,
+                    priority: 2,
+                })),
+                ...(executionMode.mode === 'worktree'
+                    ? [
+                        {
+                            type: 'isolation',
+                            description: 'Changes isolated in worktree for safety',
+                            priority: 1,
+                        },
+                    ]
+                    : [
+                        {
+                            type: 'monitoring',
+                            description: 'In-branch execution with enhanced monitoring',
+                            priority: 2,
+                        },
+                    ]),
+            ],
+            executedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error in branch-aware execution',
+            operation,
+            agentType,
+            affectedFiles: affectedFiles.length,
+        };
+    }
+}
+async function performSessionManagedWorkflow(packagePath, options = {}, sessionId, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const session = await createOrResumeSession('', {
+            packagePath,
+            sessionId,
+            options: options ?? {},
+        });
+        const context = await setupAnalysisContext(packagePath, false, signal);
+        SESSION_CONTEXTS.set(session.sessionId, {
+            packagePath,
+            context,
+            startedAt: new Date().toISOString(),
+            options,
+        });
+        const memoryMonitor = await startMemoryMonitoring(session.sessionId);
+        const cleanupPlan = await setupAutomaticCleanup(session.sessionId, {
+            removeTemporaryFiles: true,
+            clearSessionCache: true,
+            logCompletion: true,
+        });
+        const workflowExecution = {
+            session,
+            context,
+            memoryMonitor,
+            cleanupPlan,
+            managementFeatures: {
+                automaticCleanup: true,
+                memoryMonitoring: true,
+                contextPersistence: true,
+                errorRecovery: true,
+                progressTracking: true,
+            },
+        };
+        await logWorkflowStart(session.sessionId, {
+            operation: 'session_managed_workflow',
+            packagePath,
+            options,
+            features: workflowExecution.managementFeatures,
+        });
+        return {
+            sessionManaged: true,
+            sessionId: session.sessionId,
+            workflow: workflowExecution,
+            capabilities: {
+                contextAware: true,
+                memoryManaged: true,
+                autoCleanup: true,
+                errorRecoverable: true,
+                progressVisible: true,
+            },
+            controls: {
+                pause: () => pauseSession(session.sessionId),
+                resume: () => resumeSession(session.sessionId),
+                cleanup: () => performSessionCleanup(session.sessionId),
+                status: () => getSessionStatus(session.sessionId),
+            },
+            startedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        if (sessionId) {
+            await performSessionCleanup(sessionId).catch(() => {
+            });
+        }
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error in session-managed workflow',
+            packagePath,
+            sessionId,
+            cleanupAttempted: true,
+        };
+    }
+}
+function determineExecutionMode(agentType, calledByMainAgent, inWorktree, requiresWorktree) {
+    const warnings = [];
+    if (agentType === 'main' || requiresWorktree) {
+        return {
+            mode: 'worktree',
+            reason: 'Main agent or high-risk operation requires worktree isolation',
+            warnings,
+        };
+    }
+    if (calledByMainAgent && !inWorktree) {
+        warnings.push('Called by main agent but not in worktree - creating worktree');
+        return {
+            mode: 'worktree',
+            reason: 'Main agent delegation requires worktree',
+            warnings,
+        };
+    }
+    if (inWorktree) {
+        return {
+            mode: 'worktree',
+            reason: 'Already in worktree - continuing in isolation',
+            warnings,
+        };
+    }
+    return {
+        mode: 'in-branch',
+        reason: 'Direct subagent call - in-branch execution with safeguards',
+        warnings,
+    };
+}
+async function createBranchProtection(operation, affectedFiles) {
+    return {
+        enabled: true,
+        operation,
+        affectedFiles,
+        protections: [
+            'Backup created before modifications',
+            'Change tracking enabled',
+            'Rollback capability maintained',
+            'File-level monitoring active',
+        ],
+        createdAt: new Date().toISOString(),
+    };
+}
+async function setupRiskMitigation(operation, packagePath) {
+    return {
+        operation,
+        packagePath,
+        mitigations: [
+            'Incremental change application',
+            'Validation at each step',
+            'Early failure detection',
+            'Automatic rollback on critical errors',
+        ],
+        monitoringLevel: 'enhanced',
+        setupAt: new Date().toISOString(),
+    };
+}
+async function startMemoryMonitoring(sessionId) {
+    return {
+        sessionId,
+        monitoring: true,
+        thresholds: {
+            warning: '80%',
+            critical: '90%',
+            emergency: '95%',
+        },
+        interval: 30000,
+        startedAt: new Date().toISOString(),
+    };
+}
+async function setupAutomaticCleanup(sessionId, options) {
+    return {
+        sessionId,
+        enabled: true,
+        options,
+        triggers: ['workflow_completion', 'error_termination', 'manual_cleanup', 'session_timeout'],
+        scheduledAt: new Date().toISOString(),
+    };
+}
+async function logWorkflowStart(sessionId, details) {
+    const logEntry = {
+        sessionId,
+        event: 'workflow_start',
+        timestamp: new Date().toISOString(),
+        details,
+    };
+    logInfo('[Workflow Orchestrator]', logEntry);
+    return logEntry;
+}
+async function pauseSession(sessionId) {
+    return { sessionId, paused: true, pausedAt: new Date().toISOString() };
+}
+async function resumeSession(sessionId) {
+    return { sessionId, resumed: true, resumedAt: new Date().toISOString() };
+}
+async function performSessionCleanup(sessionId) {
+    return { sessionId, cleaned: true, cleanedAt: new Date().toISOString() };
+}
+async function getSessionStatus(sessionId) {
+    return {
+        sessionId,
+        status: 'active',
+        checkedAt: new Date().toISOString(),
+        uptime: process.uptime() * 1000,
+    };
+}
+function getSessionDirectory(sessionId) {
+    const baseDir = join(tmpdir(), 'claude-agent-sessions');
+    return sessionId ? join(baseDir, sessionId) : baseDir;
+}
+async function streamFileDiscovery(packagePath, options = {}, sessionId, signal) {
+    const monitor = getGlobalMemoryMonitor({ enableAutoGC: true });
+    monitor.startMonitoring();
+    const batchSize = asNumber(options.batchSize) ?? 500;
+    const results = [];
+    const errors = [];
+    let processedFiles = 0;
+    const memoryStats = {
+        peakUsageMB: 0,
+        averageUsageMB: 0,
+        gcTriggered: 0,
+    };
+    try {
+        const context = await setupAnalysisContext(packagePath, false, signal);
+        const fileDiscovery = await discoverProjectFiles(packagePath, context, sessionId);
+        const allFiles = [
+            ...fileDiscovery.sourceFiles,
+            ...fileDiscovery.testFiles,
+            ...fileDiscovery.configFiles,
+        ];
+        if (allFiles.length === 0) {
+            return {
+                success: true,
+                totalFiles: 0,
+                processedFiles: 0,
+                batchesCompleted: 0,
+                totalBatches: 0,
+                results: [],
+                errors: [],
+                memoryStats,
+            };
+        }
+        const batchProcessor = new BatchProcessorEngine({
+            batchSize,
+            memoryThreshold: 80,
+            enableGC: true,
+            sessionId,
+        });
+        const processBatch = async (batch, batchIndex, batchSignal) => {
+            safeThrowIfAborted(batchSignal);
+            const batchResults = [];
+            for (const file of batch) {
+                try {
+                    const stat = await fs.stat(file);
+                    const fileAnalysis = await analyzeFileContent(file, {
+                        packagePath: packagePath ?? '.',
+                        sessionId: sessionId ?? 'default',
+                        batchIndex,
+                        signal: batchSignal,
+                    });
+                    const fileInfo = {
+                        path: file,
+                        size: stat.size,
+                        type: getFileType(file),
+                        processed: true,
+                        batchIndex,
+                        lastModified: stat.mtime.getTime(),
+                        analysis: fileAnalysis,
+                    };
+                    batchResults.push(fileInfo);
+                    if (sessionId && batchIndex % 5 === 0) {
+                        await updateSessionProgress(sessionId, file, batchResults.length);
+                    }
+                }
+                catch (error) {
+                    const fileError = new Error(`Analysis failed for ${file}: ${error instanceof Error ? error.message : String(error)}`);
+                    fileError.path = file;
+                    fileError.batchIndex = batchIndex;
+                    fileError.timestamp = Date.now();
+                    errors.push(fileError);
+                    batchResults.push({
+                        path: file,
+                        size: 0,
+                        type: 'unknown',
+                        processed: false,
+                        batchIndex,
+                        error: fileError.message,
+                    });
+                }
+            }
+            return batchResults;
+        };
+        batchProcessor.onProgress(progress => {
+            processedFiles = progress.processedItems;
+            const currentSnapshot = monitor.getMemoryStats();
+            memoryStats.peakUsageMB = Math.max(memoryStats.peakUsageMB, currentSnapshot.current.heapUsed);
+        });
+        const batchResult = await batchProcessor.process(allFiles, processBatch, signal);
+        results.push(...batchResult.results);
+        errors.push(...batchResult.errors);
+        const finalSnapshot = monitor.getMemoryStats();
+        memoryStats.gcTriggered = finalSnapshot.gcHistory.length;
+        memoryStats.averageUsageMB = memoryStats.peakUsageMB * 0.7;
+        return {
+            success: batchResult.success,
+            totalFiles: allFiles.length,
+            processedFiles: batchResult.progress.processedItems,
+            batchesCompleted: batchResult.progress.completedBatches,
+            totalBatches: batchResult.progress.totalBatches,
+            results,
+            errors,
+            memoryStats,
+        };
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+        return {
+            success: false,
+            totalFiles: 0,
+            processedFiles,
+            batchesCompleted: 0,
+            totalBatches: 0,
+            results,
+            errors,
+            memoryStats,
+        };
+    }
+    finally {
+        monitor.stopMonitoring();
+    }
+}
+async function performIncrementalAnalysis(packagePath, files, options = {}, sessionId, signal) {
+    const checkpointInterval = asNumber(options.checkpointInterval) ?? 100;
+    const batchSize = asNumber(options.batchSize) ?? 50;
+    let checkpoint = null;
+    let startIndex = 0;
+    if (sessionId) {
+        try {
+            checkpoint = await loadAnalysisCheckpoint(sessionId);
+            if (checkpoint) {
+                startIndex = checkpoint.processedFiles.length;
+            }
+        }
+        catch (_error) {
+        }
+    }
+    const remainingFiles = files.slice(startIndex);
+    const results = checkpoint?.analysisResults
+        ? Object.values(checkpoint.analysisResults)
+        : [];
+    const errors = checkpoint?.errors ?? [];
+    try {
+        let processedCount = startIndex;
+        const batchCount = Math.ceil(startIndex / batchSize);
+        const batchProcessor = new BatchProcessorEngine({
+            batchSize,
+            memoryThreshold: 75,
+            enableGC: true,
+            sessionId: sessionId || `incremental_${Date.now()}`,
+        });
+        const processBatch = async (batch, batchIndex) => {
+            const batchResults = [];
+            for (const file of batch) {
+                safeThrowIfAborted(signal);
+                try {
+                    let analysisResult;
+                    try {
+                        const stats = await fs.stat(file);
+                        const extension = extname(file);
+                        analysisResult = {
+                            file,
+                            analyzed: true,
+                            timestamp: Date.now(),
+                            batchIndex: batchCount + batchIndex,
+                            fileStats: {
+                                size: stats.size,
+                                extension,
+                                isDirectory: stats.isDirectory(),
+                                lastModified: stats.mtime.toISOString(),
+                            },
+                        };
+                    }
+                    catch (fileError) {
+                        analysisResult = {
+                            file,
+                            analyzed: false,
+                            error: fileError instanceof Error ? fileError.message : 'Unknown file error',
+                            timestamp: Date.now(),
+                            batchIndex: batchCount + batchIndex,
+                        };
+                    }
+                    batchResults.push(analysisResult);
+                    processedCount++;
+                    if (sessionId && processedCount % checkpointInterval === 0) {
+                        await saveAnalysisCheckpoint(sessionId, {
+                            processedFiles: files.slice(0, processedCount),
+                            results: [...results, ...batchResults],
+                            currentBatch: batchCount + batchIndex,
+                        }, packagePath, options);
+                    }
+                }
+                catch (error) {
+                    errors.push(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            return batchResults;
+        };
+        const batchResult = await batchProcessor.process(remainingFiles, processBatch, signal);
+        results.push(...batchResult.results);
+        if (sessionId) {
+            await saveAnalysisCheckpoint(sessionId, {
+                processedFiles: files.slice(0, processedCount),
+                results,
+                currentBatch: batchResult.progress.completedBatches,
+                completed: true,
+            }, packagePath, options);
+        }
+        return {
+            success: batchResult.success,
+            totalFiles: files.length,
+            processedFiles: processedCount,
+            batchesCompleted: batchResult.progress.completedBatches,
+            totalBatches: batchResult.progress.totalBatches,
+            results,
+            errors: [...errors, ...batchResult.errors],
+            checkpointId: checkpoint?.checkpointId,
+            memoryStats: {
+                peakUsageMB: batchResult.metrics.memoryPeak,
+                averageUsageMB: batchResult.metrics.memoryPeak * 0.7,
+                gcTriggered: batchResult.metrics.gcTriggerCount,
+            },
+        };
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error : new Error(String(error)));
+        return {
+            success: false,
+            totalFiles: files.length,
+            processedFiles: startIndex,
+            batchesCompleted: 0,
+            totalBatches: 0,
+            results,
+            errors,
+            memoryStats: { peakUsageMB: 0, averageUsageMB: 0, gcTriggered: 0 },
+        };
+    }
+}
+async function loadAnalysisCheckpoint(sessionId, checkpointId) {
+    try {
+        const sessionDir = getSessionDirectory(sessionId);
+        const checkpointFile = checkpointId
+            ? join(sessionDir, `checkpoint_${checkpointId}.json`)
+            : join(sessionDir, 'latest_checkpoint.json');
+        const data = await fs.readFile(checkpointFile, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (_error) {
+        return null;
+    }
+}
+async function saveAnalysisCheckpoint(sessionId, analysisData, packagePath, options = {}) {
+    try {
+        const sessionDir = getSessionDirectory(sessionId);
+        await fs.mkdir(sessionDir, { recursive: true });
+        const checkpointId = asString(options.checkpointId) ?? `checkpoint_${Date.now()}`;
+        const analysisResults = Array.isArray(analysisData.results)
+            ? { items: analysisData.results }
+            : (asRecord(analysisData.results) ?? {});
+        const checkpoint = {
+            sessionId,
+            checkpointId,
+            timestamp: Date.now(),
+            totalFiles: analysisData.totalFiles ?? 0,
+            processedFiles: analysisData.processedFiles ?? [],
+            currentBatch: analysisData.currentBatch ?? 0,
+            totalBatches: analysisData.totalBatches ?? 0,
+            analysisResults,
+            memorySnapshot: { timestamp: Date.now(), usage: getMemoryUsage() },
+            errors: analysisData.errors ?? [],
+            metadata: {
+                packagePath: packagePath ?? '',
+                workingDirectory: asString(options.workingDirectory),
+                batchSize: asNumber(options.batchSize) ?? 100,
+                startTime: asNumber(options.startTime) ?? Date.now(),
+                lastSaveTime: Date.now(),
+            },
+        };
+        const checkpointFile = join(sessionDir, `checkpoint_${checkpointId}.json`);
+        const latestFile = join(sessionDir, 'latest_checkpoint.json');
+        await Promise.all([
+            fs.writeFile(checkpointFile, JSON.stringify(checkpoint, null, 2)),
+            fs.writeFile(latestFile, JSON.stringify(checkpoint, null, 2)),
+        ]);
+        return {
+            checkpointId,
+            saved: true,
+            path: checkpointFile,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to save checkpoint: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function resumeAnalysisFromCheckpoint(sessionId, checkpointId, signal) {
+    try {
+        const checkpoint = await loadAnalysisCheckpoint(sessionId, checkpointId);
+        if (!checkpoint) {
+            return {
+                resumed: false,
+                checkpoint: null,
+                message: 'No checkpoint found for session',
+            };
+        }
+        const maxAge = 24 * 60 * 60 * 1000;
+        if (Date.now() - checkpoint.timestamp > maxAge) {
+            return {
+                resumed: false,
+                checkpoint,
+                message: 'Checkpoint is too old to resume safely',
+            };
+        }
+        return {
+            resumed: true,
+            checkpoint,
+            message: `Resumed from checkpoint with ${checkpoint.processedFiles.length} files already processed`,
+        };
+    }
+    catch (error) {
+        return {
+            resumed: false,
+            checkpoint: null,
+            message: `Failed to resume from checkpoint: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function performStreamBatchProcessing(files, options = {}, sessionId, signal) {
+    const batchSize = asNumber(options.batchSize) ?? 100;
+    const memoryThreshold = asNumber(options.memoryThreshold) ?? 80;
+    try {
+        const batchProcessor = new BatchProcessorEngine({
+            batchSize,
+            memoryThreshold,
+            enableGC: true,
+            batchDelay: asNumber(options.batchDelay) ?? 500,
+            sessionId: sessionId || `stream_${Date.now()}`,
+        });
+        const processBatch = async (batch, batchIndex) => {
+            safeThrowIfAborted(signal);
+            const batchResults = [];
+            for (const file of batch) {
+                let result;
+                try {
+                    const stats = await fs.stat(file);
+                    const extension = extname(file);
+                    const fileBasename = basename(file);
+                    result = {
+                        file,
+                        processed: true,
+                        timestamp: Date.now(),
+                        batchIndex,
+                        memoryUsed: process.memoryUsage().heapUsed,
+                        fileInfo: {
+                            name: fileBasename,
+                            extension,
+                            size: stats.size,
+                            lastModified: stats.mtime,
+                            isValid: true,
+                        },
+                    };
+                }
+                catch (error) {
+                    result = {
+                        file,
+                        processed: false,
+                        error: error instanceof Error ? error.message : 'Processing error',
+                        timestamp: Date.now(),
+                        batchIndex,
+                        memoryUsed: process.memoryUsage().heapUsed,
+                        fileInfo: {
+                            name: basename(file),
+                            isValid: false,
+                        },
+                    };
+                }
+                batchResults.push(result);
+            }
+            return batchResults;
+        };
+        const result = await batchProcessor.process(files, processBatch, signal);
+        return {
+            success: result.success,
+            totalFiles: files.length,
+            processedFiles: result.progress.processedItems,
+            batchesCompleted: result.progress.completedBatches,
+            totalBatches: result.progress.totalBatches,
+            results: result.results,
+            errors: result.errors,
+            memoryStats: {
+                peakUsageMB: result.metrics.memoryPeak,
+                averageUsageMB: result.metrics.memoryPeak * 0.8,
+                gcTriggered: result.metrics.gcTriggerCount,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            totalFiles: files.length,
+            processedFiles: 0,
+            batchesCompleted: 0,
+            totalBatches: 0,
+            results: [],
+            errors: [error instanceof Error ? error : new Error(String(error))],
+            memoryStats: { peakUsageMB: 0, averageUsageMB: 0, gcTriggered: 0 },
+        };
+    }
+}
+async function saveProgressToCheckpoint(sessionId, options, packagePath, workingDirectory, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const recoveryManager = getSessionRecoveryManager({
+            sessionDir: asString(options['sessionDir']) ?? '.claude-sessions',
+        });
+        const sessionContext = SESSION_CONTEXTS.get(sessionId) ?? {};
+        const sessionPackagePath = asString(sessionContext['packagePath']);
+        const sessionWorkingDirectory = asString(sessionContext['workingDirectory']);
+        const sessionProcessingState = asRecord(sessionContext['processingState']) ?? {};
+        const sessionCompletedFiles = asStringArray(sessionContext['completedFiles']) ?? [];
+        const sessionPendingFiles = asStringArray(sessionContext['pendingFiles']) ?? [];
+        const sessionResults = asRecord(sessionContext['results']) ?? {};
+        const sessionErrors = normalizeSessionCheckpointErrors(sessionContext['errors']);
+        const sessionStartTime = asNumber(sessionContext['startTime']) ?? Date.now();
+        const sessionFilesProcessed = asNumber(sessionContext['filesProcessed']) ?? 0;
+        const sessionUserMessage = asString(sessionContext['userMessage']);
+        const sessionOptions = asRecord(sessionContext['options']) ?? {};
+        const sessionCurrentPhase = asString(sessionContext['currentPhase']);
+        const sessionCurrentWorkingDirectory = asString(sessionContext['workingDirectory']);
+        const checkpoint = {
+            sessionId,
+            timestamp: Date.now(),
+            agentType: asString(options['agentType']) ?? 'code-quality',
+            packagePath: packagePath ?? sessionPackagePath ?? process.cwd(),
+            workingDirectory: workingDirectory ?? sessionWorkingDirectory ?? sessionCurrentWorkingDirectory,
+            progress: {
+                phase: asString(options['currentPhase']) ?? sessionCurrentPhase ?? 'unknown',
+                completedSteps: asNumber(options['completedSteps']) ?? 0,
+                totalSteps: asNumber(options['totalSteps']) ?? 1,
+                currentStep: asString(options['currentStep']) ?? 'processing',
+                processingState: {
+                    lastProcessedFile: asString(options['lastProcessedFile']),
+                    currentBatch: asNumber(options['currentBatch']) ?? 0,
+                    batchSize: asNumber(options['batchSize']) ?? 100,
+                    analysisConfig: asRecord(options['analysisConfig']) ?? {},
+                    ...sessionProcessingState,
+                },
+            },
+            analysis: {
+                completedFiles: asStringArray(options['completedFiles']) ?? sessionCompletedFiles,
+                pendingFiles: asStringArray(options['pendingFiles']) ?? sessionPendingFiles,
+                results: asRecord(options['analysisResults']) ?? sessionResults,
+                errors: normalizeSessionCheckpointErrors(options['errors'] ?? sessionErrors),
+            },
+            context: {
+                userMessage: asString(options['userMessage']) ?? sessionUserMessage,
+                options: asRecord(options['contextOptions']) ?? sessionOptions,
+                environment: {
+                    NODE_VERSION: process.version,
+                    PLATFORM: process.platform,
+                    MEMORY_LIMIT: process.env.AGENT_MEMORY_LIMIT_MB ?? '6144',
+                    WORKING_DIRECTORY: workingDirectory ?? process.cwd(),
+                    PACKAGE_PATH: packagePath || process.cwd(),
+                },
+            },
+            metrics: {
+                startTime: sessionStartTime,
+                lastUpdateTime: Date.now(),
+                memoryUsage: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+                filesProcessed: asNumber(options['filesProcessed']) ?? sessionFilesProcessed,
+                errorsEncountered: (Array.isArray(options['errors']) ? options['errors'].length : 0) + sessionErrors.length,
+            },
+        };
+        const saved = await recoveryManager.saveCheckpoint(checkpoint);
+        if (saved) {
+            SESSION_CONTEXTS.set(sessionId, {
+                ...sessionContext,
+                lastCheckpoint: checkpoint.timestamp,
+                checkpointSaved: true,
+            });
+            return {
+                success: true,
+                checkpointId: sessionId,
+                savedAt: checkpoint.timestamp,
+                progressData: {
+                    phase: checkpoint.progress.phase,
+                    completedSteps: checkpoint.progress.completedSteps,
+                    totalSteps: checkpoint.progress.totalSteps,
+                    filesProcessed: checkpoint.metrics.filesProcessed,
+                    memoryUsage: checkpoint.metrics.memoryUsage,
+                },
+            };
+        }
+        else {
+            throw new Error('Failed to save checkpoint to disk');
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            checkpointId: sessionId,
+            savedAt: 0,
+            progressData: {
+                phase: 'error',
+                completedSteps: 0,
+                totalSteps: 0,
+                filesProcessed: 0,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}
+async function loadProgressFromCheckpoint(sessionId, options, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const recoveryManager = getSessionRecoveryManager({
+            sessionDir: asString(options['sessionDir']) ?? '.claude-sessions',
+        });
+        const recoveryResult = await recoveryManager.recoverSession(sessionId);
+        if (recoveryResult.success && recoveryResult.checkpoint) {
+            SESSION_CONTEXTS.set(sessionId, {
+                packagePath: recoveryResult.checkpoint.packagePath,
+                workingDirectory: recoveryResult.checkpoint.workingDirectory,
+                currentPhase: recoveryResult.checkpoint.progress.phase,
+                completedFiles: recoveryResult.checkpoint.analysis.completedFiles,
+                pendingFiles: recoveryResult.checkpoint.analysis.pendingFiles,
+                results: recoveryResult.checkpoint.analysis.results,
+                errors: recoveryResult.checkpoint.analysis.errors,
+                startTime: recoveryResult.checkpoint.metrics.startTime,
+                filesProcessed: recoveryResult.checkpoint.metrics.filesProcessed,
+                userMessage: recoveryResult.checkpoint.context.userMessage,
+                options: recoveryResult.checkpoint.context.options,
+                processingState: recoveryResult.checkpoint.progress.processingState,
+                checkpointLoaded: true,
+                loadedAt: Date.now(),
+            });
+            return {
+                success: true,
+                checkpoint: recoveryResult.checkpoint,
+                resumeData: recoveryResult.resumeData,
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: recoveryResult.error ?? 'Failed to recover session',
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function listAllRecoverableSessions(sessionDir, signal) {
+    safeThrowIfAborted(signal);
+    try {
+        const recoveryManager = getSessionRecoveryManager({
+            sessionDir: sessionDir ?? '.claude-sessions',
+        });
+        const sessionSummaries = await recoveryManager.listRecoverableSessions();
+        const sessions = sessionSummaries.map(summary => ({
+            sessionId: summary.sessionId,
+            agentType: summary.agentType,
+            lastUpdate: summary.lastUpdate,
+            status: summary.status,
+            progress: summary.progress,
+            filesProcessed: summary.filesProcessed,
+            packagePath: '',
+        }));
+        const recoverableSessions = sessions.filter(s => s.status === 'crashed' || s.status === 'active').length;
+        return {
+            sessions,
+            totalSessions: sessions.length,
+            recoverableSessions,
+        };
+    }
+    catch (_error) {
+        return {
+            sessions: [],
+            totalSessions: 0,
+            recoverableSessions: 0,
+        };
+    }
+}
+async function analyzeFileContent(filePath, context) {
+    const { packagePath: _packagePath, sessionId, batchIndex, signal } = context;
+    try {
+        safeThrowIfAborted(signal);
+        const content = await fs.readFile(filePath, 'utf8');
+        const analysis = {
+            lineCount: content.split('\n').length,
+            characterCount: content.length,
+            fileType: getFileType(filePath),
+            hasTypeScript: filePath.endsWith('.ts') || filePath.endsWith('.tsx'),
+            hasReact: content.includes('React') || content.includes('jsx'),
+            imports: extractImports(content),
+            exports: extractExports(content),
+            complexity: estimateComplexity(content),
+            lastAnalyzed: Date.now(),
+            sessionId,
+            batchIndex,
+        };
+        return analysis;
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            fileType: getFileType(filePath),
+            lastAnalyzed: Date.now(),
+            sessionId,
+            batchIndex,
+        };
+    }
+}
+function getFileType(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const typeMap = {
+        '.ts': 'typescript',
+        '.tsx': 'typescript-react',
+        '.js': 'javascript',
+        '.jsx': 'javascript-react',
+        '.json': 'json',
+        '.md': 'markdown',
+        '.yml': 'yaml',
+        '.yaml': 'yaml',
+        '.css': 'css',
+        '.scss': 'scss',
+        '.sass': 'sass',
+        '.html': 'html',
+        '.py': 'python',
+        '.sh': 'shell',
+        '.mjs': 'javascript-module',
+    };
+    return typeMap[ext] ?? 'unknown';
+}
+function extractImports(content) {
+    const importRegex = /^import\s[^;]*?from\s+['"`]([^'"`]+)['"`]/gmu;
+    const requireRegex = /require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/gu;
+    const imports = [];
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+        const imported = match[1];
+        if (imported) {
+            imports.push(imported);
+        }
+    }
+    while ((match = requireRegex.exec(content)) !== null) {
+        const required = match[1];
+        if (required) {
+            imports.push(required);
+        }
+    }
+    return imports;
+}
+function extractExports(content) {
+    const exportRegex = /^export\s+(?:const|let|var|function|class)\s+(\w+)/gmu;
+    const exports = [];
+    let match;
+    while ((match = exportRegex.exec(content)) !== null) {
+        const exported = match[1];
+        if (exported) {
+            exports.push(exported);
+        }
+    }
+    return exports;
+}
+function estimateComplexity(content) {
+    const indicators = [
+        /\bif\b/g,
+        /\belse\b/g,
+        /\bfor\b/g,
+        /\bwhile\b/g,
+        /\bswitch\b/g,
+        /\bcatch\b/g,
+        /\btry\b/g,
+        /\?\s*:/g,
+    ];
+    let complexity = 1;
+    for (const regex of indicators) {
+        const matches = content.match(regex);
+        if (matches) {
+            complexity += matches.length;
+        }
+    }
+    return complexity;
+}
+async function updateSessionProgress(sessionId, currentFile, filesProcessed) {
+    try {
+        const recoveryManager = getSessionRecoveryManager();
+        const checkpoint = await recoveryManager.loadCheckpoint(sessionId);
+        if (checkpoint) {
+            checkpoint.progress.currentStep = `Processing: ${currentFile}`;
+            checkpoint.analysis.completedFiles.push(currentFile);
+            checkpoint.metrics.filesProcessed = filesProcessed;
+            checkpoint.metrics.lastUpdateTime = Date.now();
+            checkpoint.metrics.memoryUsage = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+            await recoveryManager.saveCheckpoint(checkpoint);
+        }
+    }
+    catch (error) {
+        logWarn('Failed to update session progress', { error });
+    }
+}
+//# sourceMappingURL=workflow-orchestrator.js.map