@eldrforge/kodrdriv 0.0.51 → 1.2.0

package/dist/commands/tree.js

@@ -1,12 +1,245 @@
 #!/usr/bin/env node
-import path from 'path';
-import fs from 'fs/promises';
+import path__default from 'path';
+import fs__default from 'fs/promises';
 import { exec } from 'child_process';
 import util from 'util';
 import { getLogger } from '../logging.js';
 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 { getGloballyLinkedPackages, getGitStatusSummary, getLinkedDependencies, getLinkCompatibilityProblems } from '../util/git.js';
 
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+// Global state to track published versions during tree execution - protected by mutex
+let publishedVersions = [];
+let executionContext = null;
+// Simple mutex to prevent race conditions in global state access
+class SimpleMutex {
+    async lock() {
+        return new Promise((resolve, reject)=>{
+            if (this.destroyed) {
+                reject(new Error('Mutex has been destroyed'));
+                return;
+            }
+            if (!this.locked) {
+                this.locked = true;
+                resolve();
+            } else {
+                this.queue.push(resolve);
+            }
+        });
+    }
+    unlock() {
+        if (this.destroyed) {
+            return;
+        }
+        this.locked = false;
+        const next = this.queue.shift();
+        if (next) {
+            this.locked = true;
+            try {
+                next();
+            } catch  {
+                // If resolver throws, unlock and continue with next in queue
+                this.locked = false;
+                const nextInQueue = this.queue.shift();
+                if (nextInQueue) {
+                    this.locked = true;
+                    nextInQueue();
+                }
+            }
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        this.locked = false;
+        // Reject all queued promises to prevent memory leaks
+        while(this.queue.length > 0){
+            const resolver = this.queue.shift();
+            if (resolver) {
+                try {
+                    // Treat as rejected promise to clean up
+                    resolver(new Error('Mutex destroyed'));
+                } catch  {
+                // Ignore errors from rejected resolvers
+                }
+            }
+        }
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+    constructor(){
+        _define_property(this, "locked", false);
+        _define_property(this, "queue", []);
+        _define_property(this, "destroyed", false);
+    }
+}
+const globalStateMutex = new SimpleMutex();
+// Update inter-project dependencies in package.json based on published versions
+const updateInterProjectDependencies = async (packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun)=>{
+    const storage = create({
+        log: packageLogger.info
+    });
+    const packageJsonPath = path__default.join(packageDir, 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        packageLogger.verbose('No package.json found, skipping dependency updates');
+        return false;
+    }
+    let hasChanges = false;
+    try {
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        const sectionsToUpdate = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies'
+        ];
+        for (const publishedVersion of publishedVersions){
+            const { packageName, version } = publishedVersion;
+            // Only update if this is an inter-project dependency (exists in our build tree)
+            if (!allPackageNames.has(packageName)) {
+                continue;
+            }
+            // Update the dependency in all relevant sections
+            for (const section of sectionsToUpdate){
+                const deps = packageJson[section];
+                if (deps && deps[packageName]) {
+                    const oldVersion = deps[packageName];
+                    const newVersion = `^${version}`;
+                    if (oldVersion !== newVersion) {
+                        if (isDryRun) {
+                            packageLogger.info(`Would update ${section}.${packageName}: ${oldVersion} → ${newVersion}`);
+                        } else {
+                            packageLogger.info(`Updating ${section}.${packageName}: ${oldVersion} → ${newVersion}`);
+                            deps[packageName] = newVersion;
+                        }
+                        hasChanges = true;
+                    }
+                }
+            }
+        }
+        if (hasChanges && !isDryRun) {
+            // Write updated package.json
+            await storage.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+            packageLogger.info('Inter-project dependencies updated successfully');
+        }
+    } catch (error) {
+        packageLogger.warn(`Failed to update inter-project dependencies: ${error.message}`);
+        return false;
+    }
+    return hasChanges;
+};
+// Get the context file path
+const getContextFilePath = (outputDirectory)=>{
+    const outputDir = outputDirectory || DEFAULT_OUTPUT_DIRECTORY;
+    return getOutputPath(outputDir, '.kodrdriv-context');
+};
+// Save execution context to file
+const saveExecutionContext = async (context, outputDirectory)=>{
+    const storage = create({
+        log: ()=>{}
+    }); // Silent storage for context operations
+    const contextFilePath = getContextFilePath(outputDirectory);
+    try {
+        // Ensure output directory exists
+        await storage.ensureDirectory(path__default.dirname(contextFilePath));
+        // Save context with JSON serialization that handles dates
+        const contextData = {
+            ...context,
+            startTime: context.startTime.toISOString(),
+            lastUpdateTime: context.lastUpdateTime.toISOString(),
+            publishedVersions: context.publishedVersions.map((v)=>({
+                    ...v,
+                    publishTime: v.publishTime.toISOString()
+                }))
+        };
+        await storage.writeFile(contextFilePath, JSON.stringify(contextData, null, 2), 'utf-8');
+    } catch (error) {
+        // Don't fail the entire operation if context saving fails
+        const logger = getLogger();
+        logger.warn(`Warning: Failed to save execution context: ${error.message}`);
+    }
+};
+// Load execution context from file
+const loadExecutionContext = async (outputDirectory)=>{
+    const storage = create({
+        log: ()=>{}
+    }); // Silent storage for context operations
+    const contextFilePath = getContextFilePath(outputDirectory);
+    try {
+        if (!await storage.exists(contextFilePath)) {
+            return null;
+        }
+        const contextContent = await storage.readFile(contextFilePath, 'utf-8');
+        const contextData = safeJsonParse(contextContent, contextFilePath);
+        // Restore dates from ISO strings
+        return {
+            ...contextData,
+            startTime: new Date(contextData.startTime),
+            lastUpdateTime: new Date(contextData.lastUpdateTime),
+            publishedVersions: contextData.publishedVersions.map((v)=>({
+                    ...v,
+                    publishTime: new Date(v.publishTime)
+                }))
+        };
+    } catch (error) {
+        const logger = getLogger();
+        logger.warn(`Warning: Failed to load execution context: ${error.message}`);
+        return null;
+    }
+};
+// Clean up context file
+const cleanupContext = async (outputDirectory)=>{
+    const storage = create({
+        log: ()=>{}
+    }); // Silent storage for context operations
+    const contextFilePath = getContextFilePath(outputDirectory);
+    try {
+        if (await storage.exists(contextFilePath)) {
+            await storage.deleteFile(contextFilePath);
+        }
+    } catch (error) {
+        // Don't fail if cleanup fails
+        const logger = getLogger();
+        logger.warn(`Warning: Failed to cleanup execution context: ${error.message}`);
+    }
+};
+// Extract published version from package.json after successful publish
+const extractPublishedVersion = async (packageDir, packageLogger)=>{
+    const storage = create({
+        log: packageLogger.info
+    });
+    const packageJsonPath = path__default.join(packageDir, 'package.json');
+    try {
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        return {
+            packageName: packageJson.name,
+            version: packageJson.version,
+            publishTime: new Date()
+        };
+    } catch (error) {
+        packageLogger.warn(`Failed to extract published version: ${error.message}`);
+        return null;
+    }
+};
 // Enhanced run function that can show output based on log level
 const runWithLogging = async (command, packageLogger, options = {}, showOutput = 'none')=>{
     const execPromise = util.promisify(exec);
@@ -108,24 +341,24 @@ const matchesPattern = (filePath, pattern)=>{
     .replace(/\?/g, '.') // ? matches any single character
     .replace(/\./g, '\\.'); // Escape literal dots
     const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(filePath) || regex.test(path.basename(filePath));
+    return regex.test(filePath) || regex.test(path__default.basename(filePath));
 };
 const shouldExclude = (packageJsonPath, excludedPatterns)=>{
     if (!excludedPatterns || excludedPatterns.length === 0) {
         return false;
     }
     // Check both the full path and relative path patterns
-    const relativePath = path.relative(process.cwd(), packageJsonPath);
-    return excludedPatterns.some((pattern)=>matchesPattern(packageJsonPath, pattern) || matchesPattern(relativePath, pattern) || matchesPattern(path.dirname(packageJsonPath), pattern) || matchesPattern(path.dirname(relativePath), pattern));
+    const relativePath = path__default.relative(process.cwd(), packageJsonPath);
+    return excludedPatterns.some((pattern)=>matchesPattern(packageJsonPath, pattern) || matchesPattern(relativePath, pattern) || matchesPattern(path__default.dirname(packageJsonPath), pattern) || matchesPattern(path__default.dirname(relativePath), pattern));
 };
 const scanForPackageJsonFiles = async (directory, excludedPatterns = [])=>{
     const logger = getLogger();
     const packageJsonPaths = [];
     try {
         // First check if there's a package.json in the specified directory itself
-        const directPackageJsonPath = path.join(directory, 'package.json');
+        const directPackageJsonPath = path__default.join(directory, 'package.json');
         try {
-            await fs.access(directPackageJsonPath);
+            await fs__default.access(directPackageJsonPath);
             // Check if this package should be excluded
             if (!shouldExclude(directPackageJsonPath, excludedPatterns)) {
                 packageJsonPaths.push(directPackageJsonPath);
@@ -137,15 +370,15 @@ const scanForPackageJsonFiles = async (directory, excludedPatterns = [])=>{
         // No package.json in the root of this directory, that's fine
         }
         // Then scan subdirectories for package.json files
-        const entries = await fs.readdir(directory, {
+        const entries = await fs__default.readdir(directory, {
             withFileTypes: true
         });
         for (const entry of entries){
             if (entry.isDirectory()) {
-                const subDirPath = path.join(directory, entry.name);
-                const packageJsonPath = path.join(subDirPath, 'package.json');
+                const subDirPath = path__default.join(directory, entry.name);
+                const packageJsonPath = path__default.join(subDirPath, 'package.json');
                 try {
-                    await fs.access(packageJsonPath);
+                    await fs__default.access(packageJsonPath);
                     // Check if this package should be excluded
                     if (shouldExclude(packageJsonPath, excludedPatterns)) {
                         logger.verbose(`Excluding package.json at: ${packageJsonPath} (matches exclusion pattern)`);
@@ -192,7 +425,7 @@ const parsePackageJson = async (packageJsonPath)=>{
         return {
             name: packageJson.name,
             version: packageJson.version || '0.0.0',
-            path: path.dirname(packageJsonPath),
+            path: path__default.dirname(packageJsonPath),
             dependencies,
             localDependencies: new Set() // Will be populated later
         };
@@ -318,7 +551,7 @@ const groupPackagesByDependencyLevels = (graph, buildOrder, runConfig)=>{
     return levels;
 };
 // Execute a single package and return execution result
-const executePackage = async (packageName, packageInfo, commandToRun, runConfig, isDryRun, index, total, isBuiltInCommand = false)=>{
+const executePackage = async (packageName, packageInfo, commandToRun, runConfig, isDryRun, index, total, allPackageNames, isBuiltInCommand = false)=>{
     const packageLogger = createPackageLogger(packageName, index + 1, total, isDryRun);
     const packageDir = packageInfo.path;
     const logger = getLogger();
@@ -341,6 +574,26 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     }
     try {
         if (isDryRun) {
+            // Handle inter-project dependency updates for publish commands in dry run mode
+            if (isBuiltInCommand && commandToRun.includes('publish') && publishedVersions.length > 0) {
+                let mutexLocked = false;
+                try {
+                    await globalStateMutex.lock();
+                    mutexLocked = true;
+                    packageLogger.info('Would check for inter-project dependency updates before publish...');
+                    const versionSnapshot = [
+                        ...publishedVersions
+                    ]; // Create safe copy
+                    globalStateMutex.unlock();
+                    mutexLocked = false;
+                    await updateInterProjectDependencies(packageDir, versionSnapshot, allPackageNames, packageLogger, isDryRun);
+                } catch (error) {
+                    if (mutexLocked) {
+                        globalStateMutex.unlock();
+                    }
+                    throw error;
+                }
+            }
             // Use main logger for the specific message tests expect
             logger.info(`DRY RUN: Would execute: ${commandToRun}`);
             if (runConfig.debug || runConfig.verbose) {
@@ -350,10 +603,39 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
             // Change to the package directory and run the command
             const originalCwd = process.cwd();
             try {
+                // Validate package directory exists before changing to it
+                try {
+                    await fs__default.access(packageDir);
+                    const stat = await fs__default.stat(packageDir);
+                    if (!stat.isDirectory()) {
+                        throw new Error(`Path is not a directory: ${packageDir}`);
+                    }
+                } catch (accessError) {
+                    throw new Error(`Cannot access package directory: ${packageDir} - ${accessError.message}`);
+                }
                 process.chdir(packageDir);
                 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) {
+                    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({
+                                ...runConfig,
+                                dryRun: false
+                            });
+                            packageLogger.info('Inter-project dependency updates committed successfully');
+                        } catch (commitError) {
+                            packageLogger.warn(`Failed to commit inter-project dependency updates: ${commitError.message}`);
+                        // Continue with publish anyway - the updates are still in place
+                        }
+                    }
+                }
                 if (runConfig.debug || runConfig.verbose) {
                     if (isBuiltInCommand) {
                         packageLogger.info(`Executing built-in command: ${commandToRun}`);
@@ -375,6 +657,26 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     // For custom commands, use the existing logic
                     await runWithLogging(commandToRun, packageLogger, {}, showOutput);
                 }
+                // Track published version after successful publish
+                if (isBuiltInCommand && commandToRun.includes('publish')) {
+                    const publishedVersion = await extractPublishedVersion(packageDir, packageLogger);
+                    if (publishedVersion) {
+                        let mutexLocked = false;
+                        try {
+                            await globalStateMutex.lock();
+                            mutexLocked = true;
+                            publishedVersions.push(publishedVersion);
+                            packageLogger.info(`Tracked published version: ${publishedVersion.packageName}@${publishedVersion.version}`);
+                            globalStateMutex.unlock();
+                            mutexLocked = false;
+                        } catch (error) {
+                            if (mutexLocked) {
+                                globalStateMutex.unlock();
+                            }
+                            throw error;
+                        }
+                    }
+                }
                 if (runConfig.debug || runConfig.verbose) {
                     packageLogger.info(`Command completed successfully`);
                 } else {
@@ -382,9 +684,20 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
                     logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
                 }
             } finally{
-                process.chdir(originalCwd);
-                if (runConfig.debug) {
-                    packageLogger.debug(`Restored working directory to: ${originalCwd}`);
+                // Safely restore working directory
+                try {
+                    // Validate original directory still exists before changing back
+                    const fs = await import('fs/promises');
+                    await fs.access(originalCwd);
+                    process.chdir(originalCwd);
+                    if (runConfig.debug) {
+                        packageLogger.debug(`Restored working directory to: ${originalCwd}`);
+                    }
+                } catch (restoreError) {
+                    // If we can't restore to original directory, at least log the issue
+                    packageLogger.error(`Failed to restore working directory to ${originalCwd}: ${restoreError.message}`);
+                    packageLogger.error(`Current working directory is now: ${process.cwd()}`);
+                // Don't throw here to avoid masking the original error
                 }
             }
         }
@@ -404,22 +717,62 @@ const executePackage = async (packageName, packageInfo, commandToRun, runConfig,
     }
 };
 const execute = async (runConfig)=>{
-    var _runConfig_tree, _runConfig_tree1;
+    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2;
     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;
+    // Handle continue mode
+    if (isContinue) {
+        const savedContext = await loadExecutionContext(runConfig.outputDirectory);
+        if (savedContext) {
+            logger.info('Continuing previous tree execution...');
+            logger.info(`Original command: ${savedContext.command}`);
+            logger.info(`Started: ${savedContext.startTime.toISOString()}`);
+            logger.info(`Previously completed: ${savedContext.completedPackages.length}/${savedContext.buildOrder.length} packages`);
+            // Restore state safely
+            let mutexLocked = false;
+            try {
+                await globalStateMutex.lock();
+                mutexLocked = true;
+                publishedVersions = savedContext.publishedVersions;
+                globalStateMutex.unlock();
+                mutexLocked = false;
+            } catch (error) {
+                if (mutexLocked) {
+                    globalStateMutex.unlock();
+                }
+                throw error;
+            }
+            executionContext = savedContext;
+            // Use original config but allow some overrides (like dry run)
+            runConfig = {
+                ...savedContext.originalConfig,
+                dryRun: runConfig.dryRun,
+                outputDirectory: runConfig.outputDirectory || savedContext.originalConfig.outputDirectory
+            };
+        } else {
+            logger.warn('No previous execution context found. Starting new execution...');
+        }
+    } else {
+        // Reset published versions tracking for new tree execution
+        publishedVersions = [];
+        executionContext = null;
+    }
     // Check if we're in built-in command mode (tree command with second argument)
-    const builtInCommand = (_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.builtInCommand;
+    const builtInCommand = (_runConfig_tree1 = runConfig.tree) === null || _runConfig_tree1 === void 0 ? void 0 : _runConfig_tree1.builtInCommand;
     const supportedBuiltInCommands = [
         'commit',
         'publish',
         'link',
-        'unlink'
+        'unlink',
+        'development',
+        'branches'
     ];
     if (builtInCommand && !supportedBuiltInCommands.includes(builtInCommand)) {
         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_tree1 = runConfig.tree) === null || _runConfig_tree1 === void 0 ? void 0 : _runConfig_tree1.directories) || [
+    const targetDirectories = ((_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.directories) || [
         process.cwd()
     ];
     if (targetDirectories.length === 1) {
@@ -428,9 +781,9 @@ const execute = async (runConfig)=>{
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Analyzing workspaces at: ${targetDirectories.join(', ')}`);
     }
     try {
-        var _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5;
+        var _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7;
         // Get exclusion patterns from config, fallback to empty array
-        const excludedPatterns = ((_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.excludedPatterns) || [];
+        const excludedPatterns = ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.excludedPatterns) || [];
         if (excludedPatterns.length > 0) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Using exclusion patterns: ${excludedPatterns.join(', ')}`);
         }
@@ -457,13 +810,13 @@ 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_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.startFrom;
+        const startFrom = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.startFrom;
         if (startFrom) {
             logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
             // Find the package that matches the startFrom directory name
             const startIndex = buildOrder.findIndex((packageName)=>{
                 const packageInfo = dependencyGraph.packages.get(packageName);
-                const dirName = path.basename(packageInfo.path);
+                const dirName = path__default.basename(packageInfo.path);
                 return dirName === startFrom || packageName === startFrom;
             });
             if (startIndex === -1) {
@@ -477,7 +830,7 @@ const execute = async (runConfig)=>{
                 for (const packageJsonPath of allPackageJsonPathsForCheck){
                     try {
                         const packageInfo = await parsePackageJson(packageJsonPath);
-                        const dirName = path.basename(packageInfo.path);
+                        const dirName = path__default.basename(packageInfo.path);
                         if (dirName === startFrom || packageInfo.name === startFrom) {
                             // Check if this package was excluded
                             if (shouldExclude(packageJsonPath, excludedPatterns)) {
@@ -495,7 +848,7 @@ const execute = async (runConfig)=>{
                 } else {
                     const availablePackages = buildOrder.map((name)=>{
                         const packageInfo = dependencyGraph.packages.get(name);
-                        return `${path.basename(packageInfo.path)} (${name})`;
+                        return `${path__default.basename(packageInfo.path)} (${name})`;
                     }).join(', ');
                     throw new Error(`Package directory '${startFrom}' not found. Available packages: ${availablePackages}`);
                 }
@@ -506,13 +859,335 @@ const execute = async (runConfig)=>{
                 logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Resuming from '${startFrom}' - skipping ${skippedCount} package${skippedCount === 1 ? '' : 's'}`);
             }
         }
+        // Handle stop-at functionality if specified
+        const stopAt = (_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.stopAt;
+        if (stopAt) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for stop package: ${stopAt}`);
+            // Find the package that matches the stopAt directory name
+            const stopIndex = buildOrder.findIndex((packageName)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const dirName = path__default.basename(packageInfo.path);
+                return dirName === stopAt || packageName === stopAt;
+            });
+            if (stopIndex === -1) {
+                // Check if the package exists but was excluded across all directories
+                let allPackageJsonPathsForCheck = [];
+                for (const targetDirectory of targetDirectories){
+                    const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, []); // No exclusions
+                    allPackageJsonPathsForCheck = allPackageJsonPathsForCheck.concat(packageJsonPaths);
+                }
+                let wasExcluded = false;
+                for (const packageJsonPath of allPackageJsonPathsForCheck){
+                    try {
+                        const packageInfo = await parsePackageJson(packageJsonPath);
+                        const dirName = path__default.basename(packageInfo.path);
+                        if (dirName === stopAt || packageInfo.name === stopAt) {
+                            // Check if this package was excluded
+                            if (shouldExclude(packageJsonPath, excludedPatterns)) {
+                                wasExcluded = true;
+                                break;
+                            }
+                        }
+                    } catch  {
+                        continue;
+                    }
+                }
+                if (wasExcluded) {
+                    const excludedPatternsStr = excludedPatterns.join(', ');
+                    throw new Error(`Package directory '${stopAt}' was excluded by exclusion patterns: ${excludedPatternsStr}. Remove the exclusion pattern or choose a different stop package.`);
+                } else {
+                    const availablePackages = buildOrder.map((name)=>{
+                        const packageInfo = dependencyGraph.packages.get(name);
+                        return `${path__default.basename(packageInfo.path)} (${name})`;
+                    }).join(', ');
+                    throw new Error(`Package directory '${stopAt}' not found. Available packages: ${availablePackages}`);
+                }
+            }
+            // Truncate the build order before the stop package (the stop package is not executed)
+            const originalLength = buildOrder.length;
+            buildOrder = buildOrder.slice(0, stopIndex);
+            const stoppedCount = originalLength - stopIndex;
+            if (stoppedCount > 0) {
+                logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Stopping before '${stopAt}' - excluding ${stoppedCount} package${stoppedCount === 1 ? '' : 's'}`);
+            }
+        }
+        // Helper function to determine version scope indicator
+        const getVersionScopeIndicator = (versionRange)=>{
+            // Remove whitespace and check the pattern
+            const cleanRange = versionRange.trim();
+            // Preserve the original prefix (^, ~, >=, etc.)
+            const prefixMatch = cleanRange.match(/^([^0-9]*)/);
+            const prefix = prefixMatch ? prefixMatch[1] : '';
+            // Extract the version part after the prefix
+            const versionPart = cleanRange.substring(prefix.length);
+            // Count the number of dots to determine scope
+            const dotCount = (versionPart.match(/\./g) || []).length;
+            if (dotCount >= 2) {
+                // Has patch version (e.g., "^4.4.32" -> "^P")
+                return prefix + 'P';
+            } else if (dotCount === 1) {
+                // Has minor version only (e.g., "^4.4" -> "^m")
+                return prefix + 'm';
+            } else if (dotCount === 0 && versionPart.match(/^\d+$/)) {
+                // Has major version only (e.g., "^4" -> "^M")
+                return prefix + 'M';
+            }
+            // For complex ranges or non-standard formats, return as-is
+            return cleanRange;
+        };
+        // Helper function to find packages that consume a given package
+        const findConsumingPackagesForBranches = async (targetPackageName, allPackages, storage)=>{
+            const consumers = [];
+            // Extract scope from target package name (e.g., "@fjell/eslint-config" -> "@fjell/")
+            const targetScope = targetPackageName.includes('/') ? targetPackageName.split('/')[0] + '/' : null;
+            for (const [packageName, packageInfo] of allPackages){
+                if (packageName === targetPackageName) continue;
+                try {
+                    const packageJsonPath = path__default.join(packageInfo.path, 'package.json');
+                    const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                    const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+                    const packageJson = validatePackageJson(parsed, packageJsonPath);
+                    // Check if this package depends on the target package and get the version range
+                    const dependencyTypes = [
+                        'dependencies',
+                        'devDependencies',
+                        'peerDependencies',
+                        'optionalDependencies'
+                    ];
+                    let versionRange = null;
+                    for (const depType of dependencyTypes){
+                        if (packageJson[depType] && packageJson[depType][targetPackageName]) {
+                            versionRange = packageJson[depType][targetPackageName];
+                            break;
+                        }
+                    }
+                    if (versionRange) {
+                        // Apply scope substitution for consumers in the same scope
+                        let consumerDisplayName = packageName;
+                        if (targetScope && packageName.startsWith(targetScope)) {
+                            // Replace scope with "./" (e.g., "@fjell/core" -> "./core")
+                            consumerDisplayName = './' + packageName.substring(targetScope.length);
+                        }
+                        // Add version scope indicator
+                        const scopeIndicator = getVersionScopeIndicator(versionRange);
+                        consumerDisplayName += ` (${scopeIndicator})`;
+                        consumers.push(consumerDisplayName);
+                    }
+                } catch  {
+                    continue;
+                }
+            }
+            return consumers.sort();
+        };
+        // Handle special "branches" command that displays table
+        if (builtInCommand === 'branches') {
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Branch Status Summary:`);
+            logger.info('');
+            // Calculate column widths for nice formatting
+            let maxNameLength = 'Package'.length;
+            let maxBranchLength = 'Branch'.length;
+            let maxVersionLength = 'Version'.length;
+            let maxStatusLength = 'Status'.length;
+            let maxLinkLength = 'Linked'.length;
+            let maxConsumersLength = 'Consumers'.length;
+            const branchInfos = [];
+            // Create storage instance for consumer lookup
+            const storage = create({
+                log: ()=>{}
+            });
+            // Get globally linked packages once at the beginning
+            const globallyLinkedPackages = await getGloballyLinkedPackages();
+            // ANSI escape codes for progress display
+            const ANSI = {
+                CURSOR_UP: '\x1b[1A',
+                CURSOR_TO_START: '\x1b[0G',
+                CLEAR_LINE: '\x1b[2K',
+                GREEN: '\x1b[32m',
+                BLUE: '\x1b[34m',
+                YELLOW: '\x1b[33m',
+                RESET: '\x1b[0m',
+                BOLD: '\x1b[1m'
+            };
+            // Check if terminal supports ANSI
+            const supportsAnsi = process.stdout.isTTY && process.env.TERM !== 'dumb' && !process.env.NO_COLOR;
+            const totalPackages = buildOrder.length;
+            const concurrency = 5; // Process up to 5 packages at a time
+            let completedCount = 0;
+            let isFirstProgress = true;
+            // Function to update progress display
+            const updateProgress = (currentPackage, completed, total)=>{
+                if (!supportsAnsi) return;
+                if (!isFirstProgress) {
+                    // Move cursor up and clear the line
+                    process.stdout.write(ANSI.CURSOR_UP + ANSI.CURSOR_TO_START + ANSI.CLEAR_LINE);
+                }
+                const percentage = Math.round(completed / total * 100);
+                const progressBar = '█'.repeat(Math.floor(percentage / 5)) + '░'.repeat(20 - Math.floor(percentage / 5));
+                const progress = `${ANSI.BLUE}${ANSI.BOLD}Analyzing packages... ${ANSI.GREEN}[${progressBar}] ${percentage}%${ANSI.RESET} ${ANSI.YELLOW}(${completed}/${total})${ANSI.RESET}`;
+                const current = currentPackage ? ` - Currently: ${currentPackage}` : '';
+                process.stdout.write(progress + current + '\n');
+                isFirstProgress = false;
+            };
+            // Function to process a single package
+            const processPackage = async (packageName)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                try {
+                    // Process git status and consumers in parallel
+                    const [gitStatus, consumers] = await Promise.all([
+                        getGitStatusSummary(packageInfo.path),
+                        findConsumingPackagesForBranches(packageName, dependencyGraph.packages, storage)
+                    ]);
+                    // Check if this package is globally linked (available to be linked to)
+                    const isGloballyLinked = globallyLinkedPackages.has(packageName);
+                    const linkedText = isGloballyLinked ? '✓' : '';
+                    // Add asterisk to consumers that are actively linking to globally linked packages
+                    // and check for link problems to highlight in red
+                    const consumersWithLinkStatus = await Promise.all(consumers.map(async (consumer)=>{
+                        // Extract the base consumer name from the format "package-name (^P)" or "./scoped-name (^m)"
+                        const baseConsumerName = consumer.replace(/ \([^)]+\)$/, ''); // Remove version scope indicator
+                        // Get the original package name from display name (remove scope substitution)
+                        const originalConsumerName = baseConsumerName.startsWith('./') ? baseConsumerName.replace('./', packageName.split('/')[0] + '/') : baseConsumerName;
+                        // Find the consumer package info to get its path
+                        const consumerPackageInfo = Array.from(dependencyGraph.packages.values()).find((pkg)=>pkg.name === originalConsumerName);
+                        if (consumerPackageInfo) {
+                            const [consumerLinkedDeps, linkProblems] = await Promise.all([
+                                getLinkedDependencies(consumerPackageInfo.path),
+                                getLinkCompatibilityProblems(consumerPackageInfo.path, dependencyGraph.packages)
+                            ]);
+                            let consumerDisplay = consumer;
+                            // Add asterisk if this consumer is actively linking to this package
+                            if (consumerLinkedDeps.has(packageName)) {
+                                consumerDisplay += '*';
+                            }
+                            // Check if this consumer has link problems with the current package
+                            if (linkProblems.has(packageName)) {
+                                // Highlight in red using ANSI escape codes (only if terminal supports it)
+                                if (supportsAnsi) {
+                                    consumerDisplay = `\x1b[31m${consumerDisplay}\x1b[0m`;
+                                } else {
+                                    // Fallback for terminals that don't support ANSI colors
+                                    consumerDisplay += ' [LINK PROBLEM]';
+                                }
+                            }
+                            return consumerDisplay;
+                        }
+                        return consumer;
+                    }));
+                    return {
+                        name: packageName,
+                        branch: gitStatus.branch,
+                        version: packageInfo.version,
+                        status: gitStatus.status,
+                        linked: linkedText,
+                        consumers: consumersWithLinkStatus
+                    };
+                } catch (error) {
+                    logger.warn(`Failed to get git status for ${packageName}: ${error.message}`);
+                    return {
+                        name: packageName,
+                        branch: 'error',
+                        version: packageInfo.version,
+                        status: 'error',
+                        linked: '✗',
+                        consumers: [
+                            'error'
+                        ]
+                    };
+                }
+            };
+            // Process packages in batches with progress updates
+            updateProgress('Starting...', 0, totalPackages);
+            for(let i = 0; i < buildOrder.length; i += concurrency){
+                const batch = buildOrder.slice(i, i + concurrency);
+                // Update progress to show current batch
+                const currentBatchStr = batch.length === 1 ? batch[0] : `${batch[0]} + ${batch.length - 1} others`;
+                updateProgress(currentBatchStr, completedCount, totalPackages);
+                // Process batch in parallel
+                const batchResults = await Promise.all(batch.map((packageName)=>processPackage(packageName)));
+                // Add results and update column widths
+                for (const result of batchResults){
+                    branchInfos.push(result);
+                    maxNameLength = Math.max(maxNameLength, result.name.length);
+                    maxBranchLength = Math.max(maxBranchLength, result.branch.length);
+                    maxVersionLength = Math.max(maxVersionLength, result.version.length);
+                    maxStatusLength = Math.max(maxStatusLength, result.status.length);
+                    maxLinkLength = Math.max(maxLinkLength, result.linked.length);
+                    // For consumers, calculate the width based on the longest consumer name
+                    const maxConsumerLength = result.consumers.length > 0 ? Math.max(...result.consumers.map((c)=>c.length)) : 0;
+                    maxConsumersLength = Math.max(maxConsumersLength, maxConsumerLength);
+                }
+                completedCount += batch.length;
+                updateProgress('', completedCount, totalPackages);
+            }
+            // Clear progress line and add spacing
+            if (supportsAnsi && !isFirstProgress) {
+                process.stdout.write(ANSI.CURSOR_UP + ANSI.CURSOR_TO_START + ANSI.CLEAR_LINE);
+            }
+            logger.info(`${ANSI.GREEN}✅ Analysis complete!${ANSI.RESET} Processed ${totalPackages} packages in batches of ${concurrency}.`);
+            logger.info('');
+            // Print header (new order: Package | Branch | Version | Status | Linked | Consumers)
+            const nameHeader = 'Package'.padEnd(maxNameLength);
+            const branchHeader = 'Branch'.padEnd(maxBranchLength);
+            const versionHeader = 'Version'.padEnd(maxVersionLength);
+            const statusHeader = 'Status'.padEnd(maxStatusLength);
+            const linkHeader = 'Linked'.padEnd(maxLinkLength);
+            const consumersHeader = 'Consumers';
+            logger.info(`${nameHeader} | ${branchHeader} | ${versionHeader} | ${statusHeader} | ${linkHeader} | ${consumersHeader}`);
+            logger.info(`${'-'.repeat(maxNameLength)} | ${'-'.repeat(maxBranchLength)} | ${'-'.repeat(maxVersionLength)} | ${'-'.repeat(maxStatusLength)} | ${'-'.repeat(maxLinkLength)} | ${'-'.repeat(9)}`);
+            // Print data rows with multi-line consumers
+            for (const info of branchInfos){
+                const nameCol = info.name.padEnd(maxNameLength);
+                const branchCol = info.branch.padEnd(maxBranchLength);
+                const versionCol = info.version.padEnd(maxVersionLength);
+                const statusCol = info.status.padEnd(maxStatusLength);
+                const linkCol = info.linked.padEnd(maxLinkLength);
+                if (info.consumers.length === 0) {
+                    // No consumers - single line
+                    logger.info(`${nameCol} | ${branchCol} | ${versionCol} | ${statusCol} | ${linkCol} | `);
+                } else if (info.consumers.length === 1) {
+                    // Single consumer - single line
+                    logger.info(`${nameCol} | ${branchCol} | ${versionCol} | ${statusCol} | ${linkCol} | ${info.consumers[0]}`);
+                } else {
+                    // Multiple consumers - first consumer on same line, rest on new lines with continuous column separators
+                    logger.info(`${nameCol} | ${branchCol} | ${versionCol} | ${statusCol} | ${linkCol} | ${info.consumers[0]}`);
+                    // Additional consumers on separate lines with proper column separators
+                    const emptyNameCol = ' '.repeat(maxNameLength);
+                    const emptyBranchCol = ' '.repeat(maxBranchLength);
+                    const emptyVersionCol = ' '.repeat(maxVersionLength);
+                    const emptyStatusCol = ' '.repeat(maxStatusLength);
+                    const emptyLinkCol = ' '.repeat(maxLinkLength);
+                    for(let i = 1; i < info.consumers.length; i++){
+                        logger.info(`${emptyNameCol} | ${emptyBranchCol} | ${emptyVersionCol} | ${emptyStatusCol} | ${emptyLinkCol} | ${info.consumers[i]}`);
+                    }
+                }
+            }
+            logger.info('');
+            // Add legend explaining the symbols and colors
+            logger.info('Legend:');
+            logger.info('  * = Consumer is actively linking to this package');
+            logger.info('  (^P) = Patch-level dependency (e.g., "^4.4.32")');
+            logger.info('  (^m) = Minor-level dependency (e.g., "^4.4")');
+            logger.info('  (^M) = Major-level dependency (e.g., "^4")');
+            logger.info('  (~P), (>=M), etc. = Other version prefixes preserved');
+            if (supportsAnsi) {
+                logger.info('  \x1b[31mRed text\x1b[0m = Consumer has link problems (version mismatches) with this package');
+            } else {
+                logger.info('  [LINK PROBLEM] = Consumer has link problems (version mismatches) with this package');
+            }
+            logger.info('');
+            return `Branch status summary for ${branchInfos.length} packages completed.`;
+        }
         // Display results
         logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Build order determined:`);
         let returnOutput = '';
         if (runConfig.verbose || runConfig.debug) {
             // Verbose mode: Skip simple format, show detailed format before command execution
             logger.info(''); // Add spacing
-            logger.info(`Detailed Build Order for ${buildOrder.length} packages${startFrom ? ` (starting from ${startFrom})` : ''}:`);
+            const rangeInfo = [];
+            if (startFrom) rangeInfo.push(`starting from ${startFrom}`);
+            if (stopAt) rangeInfo.push(`stopping before ${stopAt}`);
+            const rangeStr = rangeInfo.length > 0 ? ` (${rangeInfo.join(', ')})` : '';
+            logger.info(`Detailed Build Order for ${buildOrder.length} packages${rangeStr}:`);
             logger.info('==========================================');
             buildOrder.forEach((packageName, index)=>{
                 const packageInfo = dependencyGraph.packages.get(packageName);
@@ -544,27 +1219,74 @@ const execute = async (runConfig)=>{
             returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
         }
         // Execute command if provided (custom command or built-in command)
-        const cmd = (_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.cmd;
-        const useParallel = ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.parallel) || false;
+        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;
         // Determine command to execute
         let commandToRun;
         let isBuiltInCommand = false;
         if (builtInCommand) {
+            var _runConfig_tree8, _runConfig_tree9;
             // Built-in command mode: shell out to kodrdriv subprocess
-            commandToRun = `kodrdriv ${builtInCommand}`;
+            // Build command with propagated global options
+            const globalOptions = [];
+            // Propagate global flags that should be inherited by subprocesses
+            if (runConfig.debug) globalOptions.push('--debug');
+            if (runConfig.verbose) globalOptions.push('--verbose');
+            if (runConfig.dryRun) globalOptions.push('--dry-run');
+            if (runConfig.overrides) globalOptions.push('--overrides');
+            // Propagate global options with values
+            if (runConfig.model) globalOptions.push(`--model "${runConfig.model}"`);
+            if (runConfig.configDirectory) globalOptions.push(`--config-dir "${runConfig.configDirectory}"`);
+            if (runConfig.outputDirectory) globalOptions.push(`--output-dir "${runConfig.outputDirectory}"`);
+            if (runConfig.preferencesDirectory) globalOptions.push(`--preferences-dir "${runConfig.preferencesDirectory}"`);
+            // 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 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)) {
+                commandSpecificOptions += ' --clean-node-modules';
+            }
+            commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
             isBuiltInCommand = true;
         } else if (cmd) {
             // Custom command mode
             commandToRun = cmd;
         }
         if (commandToRun) {
+            // Create set of all package names for inter-project dependency detection
+            const allPackageNames = new Set(Array.from(dependencyGraph.packages.keys()));
+            // Initialize execution context if not continuing
+            if (!executionContext) {
+                executionContext = {
+                    command: commandToRun,
+                    originalConfig: runConfig,
+                    publishedVersions: [],
+                    completedPackages: [],
+                    buildOrder: buildOrder,
+                    startTime: new Date(),
+                    lastUpdateTime: new Date()
+                };
+                // Save initial context
+                if (isBuiltInCommand && builtInCommand === 'publish' && !isDryRun) {
+                    await saveExecutionContext(executionContext, runConfig.outputDirectory);
+                }
+            }
             // 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}...`);
+            // Show info for publish commands
+            if (isBuiltInCommand && builtInCommand === 'publish') {
+                logger.info('Inter-project dependencies will be automatically updated before each publish.');
+            }
             let successCount = 0;
             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);
@@ -605,7 +1327,7 @@ const execute = async (runConfig)=>{
                     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, isBuiltInCommand);
+                        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);
@@ -632,7 +1354,7 @@ const execute = async (runConfig)=>{
                                     logger.error(formattedError);
                                     logger.error(`Failed after ${successCount} successful packages.`);
                                     const packageDir = dependencyGraph.packages.get(packageName).path;
-                                    const packageDirName = path.basename(packageDir);
+                                    const packageDirName = path__default.basename(packageDir);
                                     logger.error(`To resume from this package, run:`);
                                     if (isBuiltInCommand) {
                                         logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
@@ -650,7 +1372,7 @@ const execute = async (runConfig)=>{
                                 packageLogger.error(`Unexpected error: ${result.reason}`);
                                 logger.error(`Failed after ${successCount} successful packages.`);
                                 const packageDir = dependencyGraph.packages.get(packageName).path;
-                                const packageDirName = path.basename(packageDir);
+                                const packageDirName = path__default.basename(packageDir);
                                 logger.error(`To resume from this package, run:`);
                                 if (isBuiltInCommand) {
                                     logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
@@ -694,13 +1416,25 @@ const execute = async (runConfig)=>{
                 }
             } else {
                 // Sequential execution
-                for(let i = 0; i < buildOrder.length; i++){
+                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;
+                    }
                     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, isBuiltInCommand);
+                    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('');
@@ -713,13 +1447,11 @@ const execute = async (runConfig)=>{
                             packageLogger.error(`Execution failed`);
                             logger.error(formattedError);
                             logger.error(`Failed after ${successCount} successful packages.`);
-                            const packageDir = packageInfo.path;
-                            const packageDirName = path.basename(packageDir);
-                            logger.error(`To resume from this package, run:`);
+                            logger.error(`To resume from this point, run:`);
                             if (isBuiltInCommand) {
-                                logger.error(`    kodrdriv tree ${builtInCommand} --start-from ${packageDirName}`);
+                                logger.error(`    kodrdriv tree ${builtInCommand} --continue`);
                             } else {
-                                logger.error(`    kodrdriv tree --start-from ${packageDirName} --cmd "${commandToRun}"`);
+                                logger.error(`    kodrdriv tree --continue --cmd "${commandToRun}"`);
                             }
                             throw new Error(`Command failed in package ${packageName}`);
                         }
@@ -730,6 +1462,10 @@ const execute = async (runConfig)=>{
             if (!failedPackage) {
                 const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed successfully! 🎉`;
                 logger.info(summary);
+                // Clean up context on successful completion
+                if (isBuiltInCommand && builtInCommand === 'publish' && !isDryRun) {
+                    await cleanupContext(runConfig.outputDirectory);
+                }
                 return returnOutput; // Don't duplicate the summary in return string
             }
         }
@@ -738,6 +1474,9 @@ const execute = async (runConfig)=>{
         const errorMessage = `Failed to analyze workspace: ${error.message}`;
         logger.error(errorMessage);
         throw new Error(errorMessage);
+    } finally{
+        // Clean up mutex resources to prevent memory leaks
+        globalStateMutex.destroy();
     }
 };