@eldrforge/kodrdriv 1.2.1 → 1.2.3

package/dist/commands/tree.js

@@ -8,7 +8,9 @@ import { create } from '../util/storage.js';
 import { safeJsonParse, validatePackageJson } from '../util/validation.js';
 import { getOutputPath } from '../util/general.js';
 import { DEFAULT_OUTPUT_DIRECTORY } from '../constants.js';
-import { execute as execute$1 } from './commit.js';
+import { execute as execute$3 } from './commit.js';
+import { execute as execute$1 } from './link.js';
+import { execute as execute$2 } from './unlink.js';
 import { getGloballyLinkedPackages, getGitStatusSummary, getLinkedDependencies, getLinkCompatibilityProblems } from '../util/git.js';
 
 function _define_property(obj, key, value) {
@@ -495,61 +497,6 @@ const topologicalSort = (graph)=>{
     logger.verbose(`Topological sort completed. Build order determined for ${result.length} packages.`);
     return result;
 };
-// Group packages into dependency levels for parallel execution
-const groupPackagesByDependencyLevels = (graph, buildOrder, runConfig)=>{
-    const logger = getLogger();
-    const { edges } = graph;
-    const levels = [];
-    const packageLevels = new Map();
-    // Calculate the dependency level for each package
-    const calculateLevel = (packageName)=>{
-        if (packageLevels.has(packageName)) {
-            return packageLevels.get(packageName);
-        }
-        const deps = edges.get(packageName) || new Set();
-        if (deps.size === 0) {
-            // No dependencies - this is level 0
-            packageLevels.set(packageName, 0);
-            if (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug) {
-                logger.debug(`${packageName}: Level 0 (no local dependencies)`);
-            }
-            return 0;
-        }
-        // Level is 1 + max level of dependencies
-        let maxDepLevel = -1;
-        for (const dep of deps){
-            const depLevel = calculateLevel(dep);
-            maxDepLevel = Math.max(maxDepLevel, depLevel);
-        }
-        const level = maxDepLevel + 1;
-        packageLevels.set(packageName, level);
-        if (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug) {
-            const depsList = Array.from(deps).join(', ');
-            logger.debug(`${packageName}: Level ${level} (depends on: ${depsList})`);
-        }
-        return level;
-    };
-    // Calculate levels for all packages
-    for (const packageName of buildOrder){
-        calculateLevel(packageName);
-    }
-    // Group packages by their levels
-    for (const packageName of buildOrder){
-        const level = packageLevels.get(packageName);
-        while(levels.length <= level){
-            levels.push([]);
-        }
-        levels[level].push(packageName);
-    }
-    // Only show grouping info if verbose or debug mode is enabled
-    if ((runConfig === null || runConfig === void 0 ? void 0 : runConfig.verbose) || (runConfig === null || runConfig === void 0 ? void 0 : runConfig.debug)) {
-        logger.verbose(`Packages grouped into ${levels.length} dependency levels for parallel execution`);
-        for(let i = 0; i < levels.length; i++){
-            logger.verbose(`  Level ${i}: ${levels[i].join(', ')}`);
-        }
-    }
-    return levels;
-};
 // Execute a single package and return execution result
 const executePackage = async (packageName, packageInfo, commandToRun, runConfig, isDryRun, index, total, allPackageNames, isBuiltInCommand = false)=>{
     const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
@@ -573,7 +520,7 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
         logger.info(`[${index + 1}/${total}] ${packageName}: Running ${commandToRun}...`);
     }
     try {
-        if (isDryRun) {
+        if (isDryRun && !isBuiltInCommand) {
             // Handle inter-project dependency updates for publish commands in dry run mode
             if (isBuiltInCommand && commandToRun.includes('publish') && publishedVersions.length > 0) {
                 let mutexLocked = false;
@@ -617,15 +564,15 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                 if (runConfig.debug) {
                     packageLogger.debug(`Changed to directory: ${packageDir}`);
                 }
-                // Handle inter-project dependency updates for publish commands before executing
-                if (isBuiltInCommand && commandToRun.includes('publish') && publishedVersions.length > 0) {
+                // Handle inter-project dependency updates for publish commands before executing (skip during dry run)
+                if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish') && publishedVersions.length > 0) {
                     packageLogger.info('Updating inter-project dependencies based on previously published packages...');
                     const hasUpdates = await updateInterProjectDependencies(packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun);
                     if (hasUpdates) {
                         // Commit the dependency updates using kodrdriv commit
                         packageLogger.info('Committing inter-project dependency updates...');
                         try {
-                            await execute$1({
+                            await execute$3({
                                 ...runConfig,
                                 dryRun: false
                             });
@@ -651,14 +598,16 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     if (runConfig.debug) {
                         packageLogger.debug(`Shelling out to separate kodrdriv process for ${builtInCommandName} command`);
                     }
+                    // Ensure dry-run propagates to subprocess even during overall dry-run mode
+                    const effectiveCommand = runConfig.dryRun && !commandToRun.includes('--dry-run') ? `${commandToRun} --dry-run` : commandToRun;
                     // Use runWithLogging for built-in commands to capture all output
-                    await runWithLogging(commandToRun, packageLogger, {}, showOutput);
+                    await runWithLogging(effectiveCommand, packageLogger, {}, showOutput);
                 } else {
                     // For custom commands, use the existing logic
                     await runWithLogging(commandToRun, packageLogger, {}, showOutput);
                 }
-                // Track published version after successful publish
-                if (isBuiltInCommand && commandToRun.includes('publish')) {
+                // Track published version after successful publish (skip during dry run)
+                if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish')) {
                     const publishedVersion = await extractPublishedVersion(packageDir, packageLogger);
                     if (publishedVersion) {
                         let mutexLocked = false;
@@ -717,7 +666,7 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     }
 };
 const execute = async (runConfig)=>{
-    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2;
+    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4;
     const logger = getLogger();
     const isDryRun = runConfig.dryRun || false;
     const isContinue = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.continue) || false;
@@ -772,32 +721,72 @@ const execute = async (runConfig)=>{
         throw new Error(`Unsupported built-in command: ${builtInCommand}. Supported commands: ${supportedBuiltInCommands.join(', ')}`);
     }
     // Determine the target directories - either specified or current working directory
-    const targetDirectories = ((_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.directories) || [
+    const directories = ((_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.directories) || [
         process.cwd()
     ];
-    if (targetDirectories.length === 1) {
-        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspace at: ${targetDirectories[0]}`);
+    // Handle link status subcommand
+    if (builtInCommand === 'link' && ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.packageArgument) === 'status') {
+        // For tree link status, we want to show status across all packages
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running link status across workspace...`);
+        // Create a config that will be passed to the link command
+        const linkConfig = {
+            ...runConfig,
+            tree: {
+                ...runConfig.tree,
+                directories: directories
+            }
+        };
+        try {
+            const result = await execute$1(linkConfig, 'status');
+            return result;
+        } catch (error) {
+            logger.error(`Link status failed: ${error.message}`);
+            throw error;
+        }
+    }
+    // Handle unlink status subcommand
+    if (builtInCommand === 'unlink' && ((_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.packageArgument) === 'status') {
+        // For tree unlink status, we want to show status across all packages
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Running unlink status across workspace...`);
+        // Create a config that will be passed to the unlink command
+        const unlinkConfig = {
+            ...runConfig,
+            tree: {
+                ...runConfig.tree,
+                directories: directories
+            }
+        };
+        try {
+            const result = await execute$2(unlinkConfig, 'status');
+            return result;
+        } catch (error) {
+            logger.error(`Unlink status failed: ${error.message}`);
+            throw error;
+        }
+    }
+    if (directories.length === 1) {
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspace at: ${directories[0]}`);
     } else {
-        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${targetDirectories.join(', ')}`);
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${directories.join(', ')}`);
     }
     try {
-        var _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7;
+        var _runConfig_tree5, _runConfig_tree6, _runConfig_tree7, _runConfig_tree8;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.excludedPatterns) || [];
+        const excludedPatterns = ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.exclude) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
         // Scan for package.json files across all directories
         logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning for package.json files...`);
         let allPackageJsonPaths = [];
-        for (const targetDirectory of targetDirectories){
+        for (const targetDirectory of directories){
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Scanning directory: ${targetDirectory}`);
             const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
             allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
         }
         const packageJsonPaths = allPackageJsonPaths;
         if (packageJsonPaths.length === 0) {
-            const directoriesStr = targetDirectories.join(', ');
+            const directoriesStr = directories.join(', ');
             const message = `No package.json files found in subdirectories of: ${directoriesStr}`;
             logger.warn(message);
             return message;
@@ -810,7 +799,7 @@ const execute = async (runConfig)=>{
         logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Determining build order...`);
         let buildOrder = topologicalSort(dependencyGraph);
         // Handle start-from functionality if specified
-        const startFrom = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.startFrom;
+        const startFrom = (_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.startFrom;
         if (startFrom) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
             // Find the package that matches the startFrom directory name
@@ -822,7 +811,7 @@ const execute = async (runConfig)=>{
             if (startIndex === -1) {
                 // Check if the package exists but was excluded across all directories
                 let allPackageJsonPathsForCheck = [];
-                for (const targetDirectory of targetDirectories){
+                for (const targetDirectory of directories){
                     const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, []); // No exclusions
                     allPackageJsonPathsForCheck = allPackageJsonPathsForCheck.concat(packageJsonPaths);
                 }
@@ -860,7 +849,7 @@ const execute = async (runConfig)=>{
             }
         }
         // Handle stop-at functionality if specified
-        const stopAt = (_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.stopAt;
+        const stopAt = (_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.stopAt;
         if (stopAt) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
             // Find the package that matches the stopAt directory name
@@ -872,7 +861,7 @@ const execute = async (runConfig)=>{
             if (stopIndex === -1) {
                 // Check if the package exists but was excluded across all directories
                 let allPackageJsonPathsForCheck = [];
-                for (const targetDirectory of targetDirectories){
+                for (const targetDirectory of directories){
                     const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, []); // No exclusions
                     allPackageJsonPathsForCheck = allPackageJsonPathsForCheck.concat(packageJsonPaths);
                 }
@@ -1219,13 +1208,12 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.cmd;
-        const useParallel = ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.parallel) || false;
+        const cmd = (_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.cmd;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
-            var _runConfig_tree8, _runConfig_tree9;
+            var _runConfig_tree9, _runConfig_tree10, _runConfig_tree11;
             // Built-in command mode: shell out to kodrdriv subprocess
             // Build command with propagated global options
             const globalOptions = [];
@@ -1242,13 +1230,16 @@ const execute = async (runConfig)=>{
             // Build the command with global options
             const optionsString = globalOptions.length > 0 ? ` ${globalOptions.join(' ')}` : '';
             // Add package argument for link/unlink commands
-            const packageArg = (_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.packageArgument;
+            const packageArg = (_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.packageArgument;
             const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink') ? ` "${packageArg}"` : '';
             // Add command-specific options
             let commandSpecificOptions = '';
-            if (builtInCommand === 'unlink' && ((_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.cleanNodeModules)) {
+            if (builtInCommand === 'unlink' && ((_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.cleanNodeModules)) {
                 commandSpecificOptions += ' --clean-node-modules';
             }
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.externals) && runConfig.tree.externals.length > 0) {
+                commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
+            }
             commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
             isBuiltInCommand = true;
         } else if (cmd) {
@@ -1277,8 +1268,7 @@ const execute = async (runConfig)=>{
             // Add spacing before command execution
             logger.info('');
             const executionDescription = isBuiltInCommand ? `built-in command "${builtInCommand}"` : `"${commandToRun}"`;
-            const parallelInfo = useParallel ? ' (with parallel execution)' : '';
-            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${executionDescription} in ${buildOrder.length} packages${parallelInfo}...`);
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${executionDescription} in ${buildOrder.length} packages...`);
             // Show info for publish commands
             if (isBuiltInCommand && builtInCommand === 'publish') {
                 logger.info('Inter-project dependencies will be automatically updated before each publish.');
@@ -1287,176 +1277,47 @@ const execute = async (runConfig)=>{
             let failedPackage = null;
             // If continuing, start from where we left off
             const startIndex = isContinue && executionContext ? executionContext.completedPackages.length : 0;
-            if (useParallel) {
-                // Parallel execution: group packages by dependency levels
-                const dependencyLevels = groupPackagesByDependencyLevels(dependencyGraph, buildOrder, runConfig);
-                if (runConfig.debug) {
-                    logger.debug(`Parallel execution strategy: ${dependencyLevels.length} dependency levels identified`);
-                    for(let i = 0; i < dependencyLevels.length; i++){
-                        const level = dependencyLevels[i];
-                        logger.debug(`  Level ${i + 1}: ${level.join(', ')} ${level.length > 1 ? '(parallel)' : '(sequential)'}`);
-                    }
+            // Sequential execution
+            for(let i = startIndex; i < buildOrder.length; i++){
+                const packageName = buildOrder[i];
+                // Skip if already completed (in continue mode)
+                if (executionContext && executionContext.completedPackages.includes(packageName)) {
+                    successCount++;
+                    continue;
                 }
-                for(let levelIndex = 0; levelIndex < dependencyLevels.length; levelIndex++){
-                    const currentLevel = dependencyLevels[levelIndex];
-                    if (runConfig.debug) {
-                        if (currentLevel.length === 1) {
-                            const packageName = currentLevel[0];
-                            logger.debug(`Starting Level ${levelIndex + 1}: ${packageName} (no dependencies within this level)`);
-                        } else {
-                            logger.debug(`Starting Level ${levelIndex + 1}: ${currentLevel.length} packages can run in parallel`);
-                            logger.debug(`  Parallel packages: ${currentLevel.join(', ')}`);
-                        }
-                    } else if (runConfig.verbose) {
-                        if (currentLevel.length === 1) {
-                            const packageName = currentLevel[0];
-                            logger.verbose(`Level ${levelIndex + 1}: Executing ${packageName}...`);
-                        } else {
-                            logger.verbose(`Level ${levelIndex + 1}: Executing ${currentLevel.length} packages in parallel: ${currentLevel.join(', ')}...`);
-                        }
-                    } else {
-                        // Basic level info
-                        if (currentLevel.length === 1) {
-                            const packageName = currentLevel[0];
-                            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing ${packageName}...`);
-                        } else {
-                            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Level ${levelIndex + 1}: Executing ${currentLevel.length} packages in parallel: ${currentLevel.join(', ')}...`);
-                        }
-                    }
-                    // Execute all packages in this level in parallel
-                    const levelPromises = currentLevel.map((packageName)=>{
-                        const packageInfo = dependencyGraph.packages.get(packageName);
-                        const globalIndex = buildOrder.indexOf(packageName);
-                        return executePackage(packageName, packageInfo, commandToRun, runConfig, isDryRun, globalIndex, buildOrder.length, allPackageNames, isBuiltInCommand);
-                    });
-                    // Wait for all packages in this level to complete
-                    const results = await Promise.allSettled(levelPromises);
-                    // Check results and handle errors
-                    for(let i = 0; i < results.length; i++){
-                        const result = results[i];
-                        const packageName = currentLevel[i];
-                        const globalIndex = buildOrder.indexOf(packageName);
-                        const packageLogger = createPackageLogger(packageName, globalIndex + 1, buildOrder.length, isDryRun);
-                        if (result.status === 'fulfilled') {
-                            if (result.value.success) {
-                                successCount++;
-                                // Add spacing between packages (except after the last one in the level)
-                                if (i < currentLevel.length - 1) {
-                                    logger.info('');
-                                    logger.info('');
-                                }
-                            } else {
-                                // Package failed
-                                failedPackage = packageName;
-                                const formattedError = formatSubprojectError(packageName, result.value.error);
-                                if (!isDryRun) {
-                                    packageLogger.error(`Execution failed`);
-                                    logger.error(formattedError);
-                                    logger.error(`Failed after ${successCount} successful packages.`);
-                                    const packageDir = dependencyGraph.packages.get(packageName).path;
-                                    const packageDirName = path__default.basename(packageDir);
-                                    logger.error(`To resume from this package, run:`);
-                                    if (isBuiltInCommand) {
-                                        logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
-                                    } else {
-                                        logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
-                                    }
-                                    throw new Error(`Command failed in package ${packageName}`);
-                                }
-                                break;
-                            }
-                        } else {
-                            // Promise was rejected
-                            failedPackage = packageName;
-                            if (!isDryRun) {
-                                packageLogger.error(`Unexpected error: ${result.reason}`);
-                                logger.error(`Failed after ${successCount} successful packages.`);
-                                const packageDir = dependencyGraph.packages.get(packageName).path;
-                                const packageDirName = path__default.basename(packageDir);
-                                logger.error(`To resume from this package, run:`);
-                                if (isBuiltInCommand) {
-                                    logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
-                                } else {
-                                    logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
-                                }
-                                throw new Error(`Unexpected error in package ${packageName}`);
-                            }
-                            break;
-                        }
-                    }
-                    // If any package failed, stop execution
-                    if (failedPackage) {
-                        break;
-                    }
-                    // Level completion logging
-                    if (runConfig.debug) {
-                        if (currentLevel.length > 1) {
-                            logger.debug(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
-                            logger.debug(`  Completed packages: ${currentLevel.join(', ')}`);
-                        } else if (currentLevel.length === 1 && successCount > 0) {
-                            const packageName = currentLevel[0];
-                            logger.debug(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
-                        }
-                    } else if (runConfig.verbose) {
-                        if (currentLevel.length > 1) {
-                            logger.verbose(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
-                        } else if (currentLevel.length === 1 && successCount > 0) {
-                            const packageName = currentLevel[0];
-                            logger.verbose(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
-                        }
-                    } else {
-                        // Basic completion info
-                        if (currentLevel.length > 1) {
-                            logger.info(`✅ Level ${levelIndex + 1} completed: all ${currentLevel.length} packages finished successfully`);
-                        } else if (currentLevel.length === 1 && successCount > 0) {
-                            const packageName = currentLevel[0];
-                            logger.info(`✅ Level ${levelIndex + 1} completed: ${packageName} finished successfully`);
-                        }
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const packageLogger = createPackageLogger(packageName, i + 1, buildOrder.length, isDryRun);
+                const result = await executePackage(packageName, packageInfo, commandToRun, runConfig, isDryRun, i, buildOrder.length, allPackageNames, isBuiltInCommand);
+                if (result.success) {
+                    successCount++;
+                    // Update context
+                    if (executionContext && isBuiltInCommand && builtInCommand === 'publish' && !isDryRun) {
+                        executionContext.completedPackages.push(packageName);
+                        executionContext.publishedVersions = publishedVersions;
+                        executionContext.lastUpdateTime = new Date();
+                        await saveExecutionContext(executionContext, runConfig.outputDirectory);
                     }
-                }
-            } else {
-                // Sequential execution
-                for(let i = startIndex; i < buildOrder.length; i++){
-                    const packageName = buildOrder[i];
-                    // Skip if already completed (in continue mode)
-                    if (executionContext && executionContext.completedPackages.includes(packageName)) {
-                        successCount++;
-                        continue;
+                    // Add spacing between packages (except after the last one)
+                    if (i < buildOrder.length - 1) {
+                        logger.info('');
+                        logger.info('');
                     }
-                    const packageInfo = dependencyGraph.packages.get(packageName);
-                    const packageLogger = createPackageLogger(packageName, i + 1, buildOrder.length, isDryRun);
-                    const result = await executePackage(packageName, packageInfo, commandToRun, runConfig, isDryRun, i, buildOrder.length, allPackageNames, isBuiltInCommand);
-                    if (result.success) {
-                        successCount++;
-                        // Update context
-                        if (executionContext && isBuiltInCommand && builtInCommand === 'publish' && !isDryRun) {
-                            executionContext.completedPackages.push(packageName);
-                            executionContext.publishedVersions = publishedVersions;
-                            executionContext.lastUpdateTime = new Date();
-                            await saveExecutionContext(executionContext, runConfig.outputDirectory);
-                        }
-                        // Add spacing between packages (except after the last one)
-                        if (i < buildOrder.length - 1) {
-                            logger.info('');
-                            logger.info('');
-                        }
-                    } else {
-                        failedPackage = packageName;
-                        const formattedError = formatSubprojectError(packageName, result.error);
-                        if (!isDryRun) {
-                            packageLogger.error(`Execution failed`);
-                            logger.error(formattedError);
-                            logger.error(`Failed after ${successCount} successful packages.`);
-                            logger.error(`To resume from this point, run:`);
-                            if (isBuiltInCommand) {
-                                logger.error(`    kodrdriv tree ${builtInCommand} --continue`);
-                            } else {
-                                logger.error(`    kodrdriv tree --continue --cmd "${commandToRun}"`);
-                            }
-                            throw new Error(`Command failed in package ${packageName}`);
+                } else {
+                    failedPackage = packageName;
+                    const formattedError = formatSubprojectError(packageName, result.error);
+                    if (!isDryRun) {
+                        packageLogger.error(`Execution failed`);
+                        logger.error(formattedError);
+                        logger.error(`Failed after ${successCount} successful packages.`);
+                        logger.error(`To resume from this point, run:`);
+                        if (isBuiltInCommand) {
+                            logger.error(`    kodrdriv tree ${builtInCommand} --continue`);
+                        } else {
+                            logger.error(`    kodrdriv tree --continue --cmd "${commandToRun}"`);
                         }
-                        break;
+                        throw new Error(`Command failed in package ${packageName}`);
                     }
+                    break;
                 }
             }
             if (!failedPackage) {
@@ -1475,8 +1336,8 @@ const execute = async (runConfig)=>{
         logger.error(errorMessage);
         throw new Error(errorMessage);
     } finally{
-        // Clean up mutex resources to prevent memory leaks
-        globalStateMutex.destroy();
+    // Intentionally preserve the mutex across executions to support multiple runs in the same process (e.g., test suite)
+    // Do not destroy here; the process lifecycle will clean up resources.
     }
 };