@eldrforge/commands-tree 0.1.0

package/dist/index.js

@@ -0,0 +1,4243 @@
+import { getLogger, getDryRunLogger, isInGitRepository, runGitWithLock, getOutputPath, DEFAULT_OUTPUT_DIRECTORY } from '@eldrforge/core';
+import { safeJsonParse, validatePackageJson, run, runSecure, getGloballyLinkedPackages, getGitStatusSummary, getLinkedDependencies, getLinkCompatibilityProblems } from '@eldrforge/git-tools';
+import * as Commit from '@eldrforge/commands-git';
+import { findAllPackageJsonFiles, PerformanceTimer, optimizePrecommitCommand, recordTestRun } from '@eldrforge/commands-git';
+import { createStorage } from '@eldrforge/shared';
+import fs from 'fs/promises';
+import path from 'path';
+import { exec } from 'child_process';
+import util from 'util';
+import { scanForPackageJsonFiles, buildDependencyGraph, topologicalSort, parsePackageJson, shouldExclude } from '@eldrforge/tree-core';
+import { SimpleMutex } from '@eldrforge/tree-execution';
+
+// Helper function to check if a path is a symbolic link
+const isSymbolicLink$1 = async (filePath)=>{
+    try {
+        const stats = await fs.lstat(filePath);
+        return stats.isSymbolicLink();
+    } catch  {
+        return false;
+    }
+};
+// Helper function to get the target of a symbolic link
+const getSymbolicLinkTarget$1 = async (filePath)=>{
+    try {
+        const target = await fs.readlink(filePath);
+        return target;
+    } catch  {
+        return null;
+    }
+};
+// Helper function to find all linked dependencies in a package
+const findLinkedDependencies$1 = async (packagePath, packageName, storage, logger)=>{
+    const linkedDependencies = [];
+    try {
+        const packageJsonPath = path.join(packagePath, 'package.json');
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        const allDependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const nodeModulesPath = path.join(packagePath, 'node_modules');
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const [dependencyName, version] of Object.entries(allDependencies)){
+            let dependencyPath;
+            if (dependencyName.startsWith('@')) {
+                // Scoped package
+                const [scope, name] = dependencyName.split('/');
+                dependencyPath = path.join(nodeModulesPath, scope, name);
+            } else {
+                // Unscoped package
+                dependencyPath = path.join(nodeModulesPath, dependencyName);
+            }
+            if (await isSymbolicLink$1(dependencyPath)) {
+                const target = await getSymbolicLinkTarget$1(dependencyPath);
+                if (target) {
+                    // Determine if this is an external dependency (not in the same workspace)
+                    const isExternal = !target.includes('node_modules') || target.startsWith('..');
+                    linkedDependencies.push({
+                        dependencyName,
+                        targetPath: target,
+                        isExternal
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        logger.warn(`LINKED_DEPS_CHECK_FAILED: Unable to check linked dependencies | Package: ${packageName} | Error: ${error.message}`);
+    }
+    return linkedDependencies;
+};
+// Helper function to check if a dependency matches any external link patterns
+const matchesExternalLinkPattern = (dependencyName, externalLinkPatterns)=>{
+    if (!externalLinkPatterns || externalLinkPatterns.length === 0) {
+        return false;
+    }
+    return externalLinkPatterns.some((pattern)=>{
+        // Simple string matching - could be enhanced with glob patterns later
+        return dependencyName === pattern || dependencyName.startsWith(pattern);
+    });
+};
+// Helper function to create symbolic links manually
+const createSymbolicLink = async (packageName, sourcePath, targetDir, logger, isDryRun = false)=>{
+    try {
+        // Parse package name to get scope and name parts
+        const [scope, name] = packageName.startsWith('@') ? packageName.split('/') : [
+            null,
+            packageName
+        ];
+        // Create the target path structure
+        const nodeModulesPath = path.join(targetDir, 'node_modules');
+        let targetPath;
+        if (scope) {
+            // Scoped package: node_modules/@scope/name
+            const scopeDir = path.join(nodeModulesPath, scope);
+            targetPath = path.join(scopeDir, name);
+            if (!isDryRun) {
+                // Ensure scope directory exists
+                await fs.mkdir(scopeDir, {
+                    recursive: true
+                });
+            }
+        } else {
+            // Unscoped package: node_modules/name
+            targetPath = path.join(nodeModulesPath, name);
+            if (!isDryRun) {
+                // Ensure node_modules directory exists
+                await fs.mkdir(nodeModulesPath, {
+                    recursive: true
+                });
+            }
+        }
+        if (isDryRun) {
+            logger.verbose(`DRY RUN: Would create symlink: ${targetPath} -> ${sourcePath}`);
+            return true;
+        }
+        // Create the symbolic link using relative path for better portability
+        const relativePath = path.relative(path.dirname(targetPath), sourcePath);
+        // Check if something already exists at the target path
+        try {
+            const stats = await fs.lstat(targetPath); // Use lstat to not follow symlinks
+            if (stats.isSymbolicLink()) {
+                // It's a symlink, check if it points to the correct target
+                const existingLink = await fs.readlink(targetPath);
+                if (existingLink === relativePath) {
+                    logger.verbose(`Symlink already exists and points to correct target: ${targetPath} -> ${relativePath}`);
+                    return true;
+                } else {
+                    logger.info(`SYMLINK_FIXING: Correcting symlink target | Path: ${targetPath} | Old Target: ${existingLink} | New Target: ${relativePath}`);
+                    await fs.unlink(targetPath);
+                    await fs.symlink(relativePath, targetPath, 'dir');
+                    logger.info(`SYMLINK_FIXED: Successfully updated symlink | Path: ${targetPath} | Target: ${relativePath} | Type: directory`);
+                    return true;
+                }
+            } else if (stats.isDirectory()) {
+                // It's a directory, remove it
+                logger.warn(`SYMLINK_DIRECTORY_CONFLICT: Removing existing directory to create symlink | Path: ${targetPath} | Type: directory | Action: Remove and replace with symlink`);
+                await fs.rm(targetPath, {
+                    recursive: true,
+                    force: true
+                });
+                await fs.symlink(relativePath, targetPath, 'dir');
+                logger.info(`SYMLINK_CREATED: Successfully created symlink after directory removal | Path: ${targetPath} | Target: ${relativePath} | Type: directory`);
+                return true;
+            } else {
+                // It's a file, remove it
+                logger.warn(`SYMLINK_FILE_CONFLICT: Removing existing file to create symlink | Path: ${targetPath} | Type: file | Action: Remove and replace with symlink`);
+                await fs.unlink(targetPath);
+                await fs.symlink(relativePath, targetPath, 'dir');
+                logger.info(`SYMLINK_CREATED: Successfully created symlink after file removal | Path: ${targetPath} | Target: ${relativePath} | Type: directory`);
+                return true;
+            }
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                // Nothing exists at target path, create the symlink
+                await fs.symlink(relativePath, targetPath, 'dir');
+                logger.verbose(`Created symlink: ${targetPath} -> ${relativePath}`);
+                return true;
+            } else {
+                throw error; // Re-throw unexpected errors
+            }
+        }
+    } catch (error) {
+        logger.warn(`SYMLINK_CREATE_FAILED: Unable to create symlink | Package: ${packageName} | Error: ${error.message} | Status: failed`);
+        return false;
+    }
+};
+// Helper function to parse package names and scopes
+const parsePackageArgument$1 = (packageArg)=>{
+    if (packageArg.startsWith('@')) {
+        const parts = packageArg.split('/');
+        if (parts.length === 1) {
+            // Just a scope like "@fjell"
+            return {
+                scope: parts[0]
+            };
+        } else {
+            // Full package name like "@fjell/core"
+            return {
+                scope: parts[0],
+                packageName: packageArg
+            };
+        }
+    } else {
+        throw new Error(`Package argument must start with @ (scope): ${packageArg}`);
+    }
+};
+// Find packages in the workspace that match the given scope or package name
+const findMatchingPackages$1 = async (targetDirectories, scope, storage, logger, packageName)=>{
+    const matchingPackages = [];
+    // Find all package.json files in target directories
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            const isInScope = packageJson.name.startsWith(scope + '/');
+            const isExactMatch = packageName && packageJson.name === packageName;
+            if (isInScope || isExactMatch) {
+                matchingPackages.push({
+                    name: packageJson.name,
+                    path: packageDir,
+                    isSource: packageName ? packageJson.name === packageName : isInScope
+                });
+            }
+        } catch (error) {
+            logger.warn(`PACKAGE_JSON_PARSE_FAILED: Unable to parse package.json | Path: ${packageJsonLocation.path} | Error: ${error.message}`);
+        }
+    }
+    return matchingPackages;
+};
+// Find packages that depend on the target package
+const findConsumingPackages$1 = async (targetDirectories, targetPackageName, storage, logger)=>{
+    const consumingPackages = [];
+    // Find all package.json files in target directories
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            // Check if this package depends on the target package
+            const dependencyTypes = [
+                'dependencies',
+                'devDependencies',
+                'peerDependencies',
+                'optionalDependencies'
+            ];
+            const hasDependency = dependencyTypes.some((depType)=>packageJson[depType] && packageJson[depType][targetPackageName]);
+            if (hasDependency && packageJson.name !== targetPackageName) {
+                consumingPackages.push({
+                    name: packageJson.name,
+                    path: packageDir
+                });
+            }
+        } catch (error) {
+            logger.warn(`Failed to parse ${packageJsonLocation.path}: ${error.message}`);
+        }
+    }
+    return consumingPackages;
+};
+const executeInternal$1 = async (runConfig, packageArgument)=>{
+    var _runConfig_link, _runConfig_tree;
+    const isDryRun = runConfig.dryRun || ((_runConfig_link = runConfig.link) === null || _runConfig_link === void 0 ? void 0 : _runConfig_link.dryRun) || false;
+    const logger = getDryRunLogger(isDryRun);
+    const storage = createStorage();
+    // Check if this is a status command
+    if (packageArgument === 'status') {
+        return await executeStatus$1(runConfig);
+    }
+    // Get target directories from config, default to current directory
+    const targetDirectories = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.directories) || [
+        process.cwd()
+    ];
+    if (targetDirectories.length === 1) {
+        logger.info(`WORKSPACE_ANALYSIS: Analyzing single workspace directory | Path: ${targetDirectories[0]} | Purpose: Find linkable packages`);
+    } else {
+        logger.info(`WORKSPACE_ANALYSIS: Analyzing multiple workspace directories | Paths: ${targetDirectories.join(', ')} | Count: ${targetDirectories.length} | Purpose: Find linkable packages across workspaces`);
+    }
+    // If no package argument provided, use new smart same-scope linking behavior
+    if (!packageArgument) {
+        var _runConfig_link1, _runConfig_link2;
+        logger.info('LINK_SMART_MODE: Smart linking mode activated for current project | Mode: smart | Target: current directory | Purpose: Auto-link dependencies based on scope');
+        // Work in current directory only - read the package.json
+        const currentDir = process.cwd();
+        const packageJsonPath = `${currentDir}/package.json`;
+        let currentPackageJson;
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+            currentPackageJson = validatePackageJson(parsed, packageJsonPath);
+        } catch (error) {
+            const message = `PACKAGE_JSON_NOT_FOUND: No valid package.json in current directory | Error: ${error.message} | Action: Cannot proceed with smart linking`;
+            logger.error(message);
+            return message;
+        }
+        if (!currentPackageJson.name) {
+            const message = 'PACKAGE_NAME_MISSING: package.json must have a name field | Field: name | Requirement: Required for linking | Action: Add name field to package.json';
+            logger.error(message);
+            return message;
+        }
+        // Extract the scope from the current package name
+        const currentScope = currentPackageJson.name.startsWith('@') ? currentPackageJson.name.split('/')[0] : null;
+        if (!currentScope) {
+            const message = 'PACKAGE_SCOPE_MISSING: Package must have scoped name for smart linking | Format Required: @scope/package | Current: ' + currentPackageJson.name + ' | Action: Use scoped package name';
+            logger.warn(message);
+            return message;
+        }
+        logger.info(`CURRENT_PACKAGE_IDENTIFIED: Current package identified for smart linking | Package: ${currentPackageJson.name} | Scope: ${currentScope} | Path: ${currentDir}`);
+        // Step 1: Link the current package globally (optional - continue even if this fails)
+        try {
+            if (isDryRun) {
+                logger.info(`SELF_LINK_DRY_RUN: Would link current package globally | Mode: dry-run | Package: ${currentPackageJson.name} | Command: npm link`);
+            } else {
+                logger.verbose(`SELF_LINK_STARTING: Registering package globally | Package: ${currentPackageJson.name} | Command: npm link | Purpose: Make available for dependency linking`);
+                await run('npm link');
+                logger.info(`SELF_LINK_SUCCESS: Current package linked globally | Package: ${currentPackageJson.name} | Location: Global npm | Purpose: Make available for linking`);
+            }
+        } catch (error) {
+            logger.warn(`SELF_LINK_FAILED: Unable to self-link current package | Package: ${currentPackageJson.name} | Error: ${error.message} | Impact: Continuing with dependency linking`);
+            logger.info(`LINK_CONTINUING: Proceeding with dependency linking despite self-link failure | Next: Link matching dependencies`);
+        }
+        // Step 2: Find same-scope dependencies in current package
+        const allDependencies = {
+            ...currentPackageJson.dependencies,
+            ...currentPackageJson.devDependencies
+        };
+        const sameScopeDependencies = Object.keys(allDependencies).filter((depName)=>depName.startsWith(currentScope + '/'));
+        // Step 2.5: Find external dependencies that match external link patterns
+        const externalLinkPatterns = ((_runConfig_link1 = runConfig.link) === null || _runConfig_link1 === void 0 ? void 0 : _runConfig_link1.externals) || [];
+        const externalDependencies = Object.keys(allDependencies).filter((depName)=>matchesExternalLinkPattern(depName, externalLinkPatterns));
+        const allDependenciesToLink = [
+            ...sameScopeDependencies,
+            ...externalDependencies
+        ];
+        if (allDependenciesToLink.length === 0) {
+            logger.info(`No same-scope or external dependencies found for ${currentScope}`);
+            if (isDryRun) {
+                return `DRY RUN: Would self-link, no dependencies found to link`;
+            } else {
+                return `Self-linked ${currentPackageJson.name}, no dependencies to link`;
+            }
+        }
+        logger.info(`Found ${sameScopeDependencies.length} same-scope dependencies: ${sameScopeDependencies.join(', ')}`);
+        if (externalDependencies.length > 0) {
+            logger.info(`Found ${externalDependencies.length} external dependencies matching patterns: ${externalDependencies.join(', ')}`);
+        }
+        // Step 2.6: Handle external dependencies using scopeRoots configuration
+        const scopeRoots = ((_runConfig_link2 = runConfig.link) === null || _runConfig_link2 === void 0 ? void 0 : _runConfig_link2.scopeRoots) || {};
+        const globallyLinkedViaScopeRoots = [];
+        if (Object.keys(scopeRoots).length > 0 && externalDependencies.length > 0) {
+            logger.info('Using scopeRoots configuration to discover and link external packages...');
+            for (const depName of externalDependencies){
+                const depScope = depName.startsWith('@') ? depName.split('/')[0] : null;
+                const scopeRoot = depScope ? scopeRoots[depScope] : null;
+                if (scopeRoot) {
+                    logger.verbose(`Processing ${depName} with scope ${depScope} -> ${scopeRoot}`);
+                    // Convert relative path to absolute
+                    const absoluteScopeRoot = path.resolve(currentDir, scopeRoot);
+                    logger.verbose(`Scanning scope root directory: ${absoluteScopeRoot}`);
+                    try {
+                        // Look for package with matching name in the scope directory
+                        const expectedPackageName = depName.startsWith('@') ? depName.split('/')[1] : depName;
+                        const packageDir = path.join(absoluteScopeRoot, expectedPackageName);
+                        const packageJsonPath = path.join(packageDir, 'package.json');
+                        logger.verbose(`Checking for package at: ${packageDir}`);
+                        try {
+                            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+                            const packageJson = validatePackageJson(parsed, packageJsonPath);
+                            if (packageJson.name === depName) {
+                                logger.info(`Found matching package: ${depName} at ${packageDir}`);
+                                if (isDryRun) {
+                                    logger.info(`DRY RUN: Would run 'npm link' in: ${packageDir}`);
+                                    globallyLinkedViaScopeRoots.push(depName);
+                                } else {
+                                    // Step A: Run 'npm link' in the source package directory
+                                    const originalCwd = process.cwd();
+                                    try {
+                                        process.chdir(packageDir);
+                                        logger.verbose(`Running 'npm link' in source: ${packageDir}`);
+                                        await run('npm link');
+                                        logger.info(`LINK_SOURCE_SCOPE_ROOTS: Source linked via scopeRoots | Package: ${depName} | Method: scopeRoots | Status: linked`);
+                                        globallyLinkedViaScopeRoots.push(depName);
+                                    } catch (linkError) {
+                                        logger.warn(`LINK_SOURCE_FAILED: Failed to link source package | Package: ${depName} | Error: ${linkError.message}`);
+                                    } finally{
+                                        process.chdir(originalCwd);
+                                    }
+                                }
+                            } else {
+                                logger.verbose(`Package name mismatch: expected ${depName}, found ${packageJson.name}`);
+                            }
+                        } catch (packageError) {
+                            logger.verbose(`Package not found or invalid: ${packageJsonPath} - ${packageError.message}`);
+                        }
+                    } catch (error) {
+                        logger.verbose(`Error processing scope ${depScope}: ${error.message}`);
+                    }
+                } else {
+                    logger.verbose(`No scope root configured for ${depScope}`);
+                }
+            }
+            if (globallyLinkedViaScopeRoots.length > 0) {
+                logger.info(`Successfully prepared ${globallyLinkedViaScopeRoots.length} packages via scopeRoots: ${globallyLinkedViaScopeRoots.join(', ')}`);
+            }
+        }
+        // Step 3: Get globally linked packages directories (only if we have dependencies to link)
+        let globallyLinkedPackages = {};
+        try {
+            if (isDryRun) {
+                logger.info(`DRY RUN: Would run 'npm ls --link -g -p' to discover linked package directories`);
+                logger.info(`DRY RUN: Would attempt to link dependencies: ${allDependenciesToLink.join(', ')}`);
+                return `DRY RUN: Would self-link and attempt to link ${allDependenciesToLink.length} dependencies`;
+            } else {
+                logger.verbose(`Discovering globally linked package directories...`);
+                const result = await run('npm ls --link -g -p');
+                const resultStr = typeof result === 'string' ? result : result.stdout;
+                // Parse the directory paths - each line is a directory path
+                const directoryPaths = resultStr.trim().split('\n').filter((line)=>line.trim() !== '');
+                // Extract package names from directory paths and build a map
+                for (const dirPath of directoryPaths){
+                    try {
+                        // Read the package.json to get the actual package name
+                        const packageJsonPath = `${dirPath.trim()}/package.json`;
+                        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+                        const packageJson = validatePackageJson(parsed, packageJsonPath);
+                        if (packageJson.name) {
+                            globallyLinkedPackages[packageJson.name] = dirPath.trim();
+                        }
+                    } catch (packageError) {
+                        logger.verbose(`Could not read package.json from ${dirPath}: ${packageError.message}`);
+                    }
+                }
+                const linkedCount = Object.keys(globallyLinkedPackages).length;
+                logger.verbose(`Found ${linkedCount} globally linked package(s)`);
+            }
+        } catch (error) {
+            logger.warn(`Failed to get globally linked packages (continuing anyway): ${error.message}`);
+            globallyLinkedPackages = {};
+        }
+        // Step 4: Link same-scope dependencies that are available globally using manual symlinks
+        const linkedDependencies = [];
+        for (const depName of allDependenciesToLink){
+            const sourcePath = globallyLinkedPackages[depName];
+            if (sourcePath) {
+                try {
+                    logger.verbose(`Linking dependency: ${depName} from ${sourcePath}`);
+                    // Create the symbolic link manually using the directory path directly
+                    const success = await createSymbolicLink(depName, sourcePath, currentDir, logger, isDryRun);
+                    if (success) {
+                        logger.info(`LINK_DEPENDENCY_SUCCESS: Linked dependency successfully | Dependency: ${depName} | Status: symlink-created`);
+                        linkedDependencies.push(depName);
+                    } else {
+                        logger.warn(`LINK_DEPENDENCY_FAILED: Failed to link dependency | Dependency: ${depName} | Status: failed`);
+                    }
+                } catch (error) {
+                    logger.warn(`⚠️ Failed to link ${depName}: ${error.message}`);
+                }
+            } else {
+                logger.verbose(`Skipping ${depName} (not globally linked)`);
+            }
+        }
+        const summary = linkedDependencies.length > 0 ? `Self-linked ${currentPackageJson.name} and linked ${linkedDependencies.length} dependencies: ${linkedDependencies.join(', ')}` : `Self-linked ${currentPackageJson.name}, no dependencies were available to link`;
+        // Step 5: Regenerate package-lock.json without modifying node_modules
+        try {
+            if (isDryRun) {
+                logger.info(`DRY RUN: Would run 'npm install --package-lock-only --no-audit --no-fund' to regenerate package-lock.json`);
+            } else {
+                logger.verbose(`Running 'npm install --package-lock-only --no-audit --no-fund' to regenerate package-lock.json without touching node_modules...`);
+                await run('npm install --package-lock-only --no-audit --no-fund');
+                logger.info(`LINK_LOCK_REGENERATED: Regenerated package-lock.json successfully | File: package-lock.json | Status: updated`);
+            }
+        } catch (error) {
+            logger.warn(`LINK_LOCK_REGEN_FAILED: Failed to regenerate package-lock.json | Error: ${error.message} | Impact: Lock file may be out of sync`);
+        }
+        logger.info(summary);
+        return summary;
+    }
+    // New scope-based linking behavior
+    logger.info(`LINK_SCOPE_MODE: Linking scope or specific package | Target: ${packageArgument} | Mode: scope-based | Purpose: Link packages by scope`);
+    const { scope, packageName } = parsePackageArgument$1(packageArgument);
+    logger.verbose(`Parsed scope: ${scope}, package: ${packageName || 'all packages in scope'}`);
+    // Find matching packages in the workspace
+    const matchingPackages = await findMatchingPackages$1(targetDirectories, scope, storage, logger, packageName);
+    if (matchingPackages.length === 0) {
+        const message = packageName ? `No package found matching: ${packageName}` : `No packages found in scope: ${scope}`;
+        logger.warn(message);
+        return message;
+    }
+    logger.info(`Found ${matchingPackages.length} matching package(s)`);
+    const linkedPackages = [];
+    // If specific package name provided, use that; otherwise link all packages in scope
+    const packagesToLink = packageName ? matchingPackages.filter((pkg)=>pkg.name === packageName) : matchingPackages;
+    for (const pkg of packagesToLink){
+        logger.info(`Processing package: ${pkg.name}`);
+        // Step A: Run 'npm link' in the source package directory
+        try {
+            const originalCwd = process.cwd();
+            process.chdir(pkg.path);
+            try {
+                if (isDryRun) {
+                    logger.info(`DRY RUN: Would run 'npm link' in: ${pkg.path}`);
+                } else {
+                    logger.verbose(`Running 'npm link' in source: ${pkg.path}`);
+                    await run('npm link');
+                    logger.info(`LINK_SOURCE_SUCCESS: Source package linked globally | Package: ${pkg.name} | Status: linked`);
+                }
+            } finally{
+                process.chdir(originalCwd);
+            }
+            // Step B: Find all packages that depend on this package and link them
+            const consumingPackages = await findConsumingPackages$1(targetDirectories, pkg.name, storage, logger);
+            if (consumingPackages.length === 0) {
+                logger.info(`No consuming packages found for: ${pkg.name}`);
+            } else {
+                logger.info(`Found ${consumingPackages.length} consuming package(s) for: ${pkg.name}`);
+                for (const consumer of consumingPackages){
+                    try {
+                        const consumerOriginalCwd = process.cwd();
+                        process.chdir(consumer.path);
+                        try {
+                            if (isDryRun) {
+                                logger.info(`DRY RUN: Would run 'npm link ${pkg.name}' in: ${consumer.path}`);
+                            } else {
+                                logger.verbose(`Running 'npm link ${pkg.name}' in consumer: ${consumer.path}`);
+                                await runSecure('npm', [
+                                    'link',
+                                    pkg.name
+                                ]);
+                                logger.info(`LINK_CONSUMER_SUCCESS: Consumer linked to package | Consumer: ${consumer.name} | Package: ${pkg.name} | Status: linked`);
+                            }
+                        } finally{
+                            process.chdir(consumerOriginalCwd);
+                        }
+                    } catch (error) {
+                        logger.error(`LINK_CONSUMER_FAILED: Failed to link package in consumer | Package: ${pkg.name} | Consumer: ${consumer.name} | Error: ${error.message}`);
+                        throw new Error(`Failed to link ${pkg.name} in consumer ${consumer.name}: ${error.message}`);
+                    }
+                }
+            }
+            linkedPackages.push(pkg.name);
+        } catch (error) {
+            logger.error(`LINK_SOURCE_PACKAGE_FAILED: Failed to link source package | Package: ${pkg.name} | Error: ${error.message}`);
+            throw new Error(`Failed to link source package ${pkg.name}: ${error.message}`);
+        }
+    }
+    const summary = `Successfully linked ${linkedPackages.length} package(s): ${linkedPackages.join(', ')}`;
+    // Final step: Regenerate package-lock.json files in all affected packages without modifying node_modules
+    if (!isDryRun) {
+        logger.info(`LINK_LOCK_REGENERATING_ALL: Regenerating package-lock.json files in all packages | Mode: lockfile-only | Purpose: Update lock files after linking`);
+        // Get all unique consuming packages
+        const allConsumingPackages = new Set();
+        for (const pkg of packagesToLink){
+            const consumingPackages = await findConsumingPackages$1(targetDirectories, pkg.name, storage, logger);
+            consumingPackages.forEach((consumer)=>allConsumingPackages.add(consumer.path));
+        }
+        // Also include the source packages
+        packagesToLink.forEach((pkg)=>allConsumingPackages.add(pkg.path));
+        // Run lockfile-only install in each package
+        for (const packagePath of allConsumingPackages){
+            try {
+                const originalCwd = process.cwd();
+                process.chdir(packagePath);
+                try {
+                    logger.verbose(`Running 'npm install --package-lock-only --no-audit --no-fund' in: ${packagePath}`);
+                    await run('npm install --package-lock-only --no-audit --no-fund');
+                    logger.verbose(`LINK_LOCK_PACKAGE_REGENERATED: Regenerated package-lock.json | Path: ${packagePath} | Status: updated`);
+                } finally{
+                    process.chdir(originalCwd);
+                }
+            } catch (error) {
+                logger.warn(`LINK_LOCK_PACKAGE_REGEN_FAILED: Failed to regenerate package-lock.json | Path: ${packagePath} | Error: ${error.message}`);
+            }
+        }
+        logger.info(`LINK_LOCK_ALL_REGENERATED: Regenerated package-lock.json files in all packages | Package Count: ${allConsumingPackages.size} | Status: completed`);
+    } else {
+        logger.info(`DRY RUN: Would run 'npm install --package-lock-only --no-audit --no-fund' to regenerate package-lock.json files in all packages`);
+    }
+    logger.info(summary);
+    return summary;
+};
+// Status function to show what's currently linked
+const executeStatus$1 = async (runConfig)=>{
+    var _runConfig_tree;
+    const logger = getLogger();
+    const storage = createStorage();
+    // Get target directories from config, default to current directory
+    const targetDirectories = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.directories) || [
+        process.cwd()
+    ];
+    if (targetDirectories.length === 1) {
+        logger.info(`🔍 Checking link status in: ${targetDirectories[0]}`);
+    } else {
+        logger.info(`🔍 Checking link status in: ${targetDirectories.join(', ')}`);
+    }
+    // Find all packages in the workspace
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    const packageStatuses = [];
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            const linkedDependencies = await findLinkedDependencies$1(packageDir, packageJson.name, storage, logger);
+            if (linkedDependencies.length > 0) {
+                packageStatuses.push({
+                    name: packageJson.name,
+                    path: packageDir,
+                    linkedDependencies
+                });
+            }
+        } catch (error) {
+            logger.warn(`Failed to parse ${packageJsonLocation.path}: ${error.message}`);
+        }
+    }
+    if (packageStatuses.length === 0) {
+        return 'No linked dependencies found in workspace.';
+    }
+    // Format the output
+    let output = `Found ${packageStatuses.length} package(s) with linked dependencies:\n\n`;
+    for (const packageStatus of packageStatuses){
+        output += `📦 ${packageStatus.name}\n`;
+        output += `   Path: ${packageStatus.path}\n`;
+        if (packageStatus.linkedDependencies.length > 0) {
+            output += `   Linked dependencies:\n`;
+            for (const dep of packageStatus.linkedDependencies){
+                const type = dep.isExternal ? '🔗 External' : '🔗 Internal';
+                output += `     ${type} ${dep.dependencyName} -> ${dep.targetPath}\n`;
+            }
+        }
+        output += '\n';
+    }
+    return output;
+};
+const execute$4 = async (runConfig, packageArgument)=>{
+    try {
+        var _runConfig_link;
+        // Use packageArgument from runConfig if not provided as parameter
+        const finalPackageArgument = packageArgument || ((_runConfig_link = runConfig.link) === null || _runConfig_link === void 0 ? void 0 : _runConfig_link.packageArgument);
+        return await executeInternal$1(runConfig, finalPackageArgument);
+    } catch (error) {
+        const logger = getLogger();
+        logger.error(`link failed: ${error.message}`);
+        throw error;
+    }
+};
+
+// Helper function to check if a dependency matches any external unlink patterns
+const matchesExternalUnlinkPattern = (dependencyName, externalUnlinkPatterns)=>{
+    if (!externalUnlinkPatterns || externalUnlinkPatterns.length === 0) {
+        return false;
+    }
+    return externalUnlinkPatterns.some((pattern)=>{
+        // Simple string matching - could be enhanced with glob patterns later
+        return dependencyName === pattern || dependencyName.startsWith(pattern);
+    });
+};
+// Helper function to check if a path is a symbolic link
+const isSymbolicLink = async (filePath)=>{
+    try {
+        const stats = await fs.lstat(filePath);
+        return stats.isSymbolicLink();
+    } catch  {
+        return false;
+    }
+};
+// Helper function to get the target of a symbolic link
+const getSymbolicLinkTarget = async (filePath)=>{
+    try {
+        const target = await fs.readlink(filePath);
+        return target;
+    } catch  {
+        return null;
+    }
+};
+// Helper function to find all linked dependencies in a package
+const findLinkedDependencies = async (packagePath, packageName, storage, logger)=>{
+    const linkedDependencies = [];
+    try {
+        const packageJsonPath = path.join(packagePath, 'package.json');
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        const allDependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const nodeModulesPath = path.join(packagePath, 'node_modules');
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const [dependencyName, version] of Object.entries(allDependencies)){
+            let dependencyPath;
+            if (dependencyName.startsWith('@')) {
+                // Scoped package
+                const [scope, name] = dependencyName.split('/');
+                dependencyPath = path.join(nodeModulesPath, scope, name);
+            } else {
+                // Unscoped package
+                dependencyPath = path.join(nodeModulesPath, dependencyName);
+            }
+            if (await isSymbolicLink(dependencyPath)) {
+                const target = await getSymbolicLinkTarget(dependencyPath);
+                if (target) {
+                    // Determine if this is an external dependency (not in the same workspace)
+                    const isExternal = !target.includes('node_modules') || target.startsWith('..');
+                    linkedDependencies.push({
+                        dependencyName,
+                        targetPath: target,
+                        isExternal
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        logger.warn(`UNLINK_CHECK_FAILED: Unable to check linked dependencies | Package: ${packageName} | Error: ${error.message}`);
+    }
+    return linkedDependencies;
+};
+// Helper function to remove symbolic links manually
+const removeSymbolicLink = async (packageName, targetDir, logger, isDryRun = false)=>{
+    try {
+        // Parse package name to get scope and name parts
+        const [scope, name] = packageName.startsWith('@') ? packageName.split('/') : [
+            null,
+            packageName
+        ];
+        // Create the target path structure
+        const nodeModulesPath = path.join(targetDir, 'node_modules');
+        let targetPath;
+        if (scope) {
+            // Scoped package: node_modules/@scope/name
+            targetPath = path.join(nodeModulesPath, scope, name);
+        } else {
+            // Unscoped package: node_modules/name
+            targetPath = path.join(nodeModulesPath, name);
+        }
+        if (isDryRun) {
+            logger.verbose(`DRY RUN: Would check and remove symlink: ${targetPath}`);
+            return true;
+        }
+        // Check if something exists at the target path
+        try {
+            const stats = await fs.lstat(targetPath); // Use lstat to not follow symlinks
+            if (stats.isSymbolicLink()) {
+                // It's a symlink, remove it
+                await fs.unlink(targetPath);
+                logger.verbose(`Removed symlink: ${targetPath}`);
+                return true;
+            } else {
+                logger.verbose(`Target exists but is not a symlink: ${targetPath}`);
+                return false;
+            }
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                // Nothing exists at target path, nothing to remove
+                logger.verbose(`No symlink found at: ${targetPath}`);
+                return true;
+            } else {
+                throw error; // Re-throw unexpected errors
+            }
+        }
+    } catch (error) {
+        logger.warn(`UNLINK_SYMLINK_REMOVE_FAILED: Unable to remove symlink | Package: ${packageName} | Error: ${error.message}`);
+        return false;
+    }
+};
+// Helper function to parse package names and scopes (same as link command)
+const parsePackageArgument = (packageArg)=>{
+    if (packageArg.startsWith('@')) {
+        const parts = packageArg.split('/');
+        if (parts.length === 1) {
+            // Just a scope like "@fjell"
+            return {
+                scope: parts[0]
+            };
+        } else {
+            // Full package name like "@fjell/core"
+            return {
+                scope: parts[0],
+                packageName: packageArg
+            };
+        }
+    } else {
+        throw new Error(`Package argument must start with @ (scope): ${packageArg}`);
+    }
+};
+// Find packages in the workspace that match the given scope or package name
+const findMatchingPackages = async (targetDirectories, scope, storage, logger, packageName)=>{
+    const matchingPackages = [];
+    // Find all package.json files in target directories
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            const isInScope = packageJson.name.startsWith(scope + '/');
+            const isExactMatch = packageName && packageJson.name === packageName;
+            if (isInScope || isExactMatch) {
+                matchingPackages.push({
+                    name: packageJson.name,
+                    path: packageDir,
+                    isSource: packageName ? packageJson.name === packageName : isInScope
+                });
+            }
+        } catch (error) {
+            logger.warn(`Failed to parse ${packageJsonLocation.path}: ${error.message}`);
+        }
+    }
+    return matchingPackages;
+};
+// Find packages that depend on the target package
+const findConsumingPackages = async (targetDirectories, targetPackageName, storage, logger)=>{
+    const consumingPackages = [];
+    // Find all package.json files in target directories
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            // Check if this package depends on the target package
+            const dependencyTypes = [
+                'dependencies',
+                'devDependencies',
+                'peerDependencies',
+                'optionalDependencies'
+            ];
+            const hasDependency = dependencyTypes.some((depType)=>packageJson[depType] && packageJson[depType][targetPackageName]);
+            if (hasDependency && packageJson.name !== targetPackageName) {
+                consumingPackages.push({
+                    name: packageJson.name,
+                    path: packageDir
+                });
+            }
+        } catch (error) {
+            logger.warn(`Failed to parse ${packageJsonLocation.path}: ${error.message}`);
+        }
+    }
+    return consumingPackages;
+};
+const executeInternal = async (runConfig, packageArgument)=>{
+    var _runConfig_unlink, _runConfig_tree;
+    const isDryRun = runConfig.dryRun || ((_runConfig_unlink = runConfig.unlink) === null || _runConfig_unlink === void 0 ? void 0 : _runConfig_unlink.dryRun) || false;
+    const logger = getDryRunLogger(isDryRun);
+    const storage = createStorage();
+    // Check if this is a status command
+    if (packageArgument === 'status') {
+        return await executeStatus(runConfig);
+    }
+    // Get target directories from config, default to current directory
+    const targetDirectories = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.directories) || [
+        process.cwd()
+    ];
+    if (targetDirectories.length === 1) {
+        logger.info(`UNLINK_WORKSPACE_ANALYSIS: Analyzing single workspace directory | Path: ${targetDirectories[0]} | Purpose: Find packages to unlink`);
+    } else {
+        logger.info(`UNLINK_WORKSPACE_ANALYSIS: Analyzing multiple workspace directories | Paths: ${targetDirectories.join(', ')} | Count: ${targetDirectories.length} | Purpose: Find packages to unlink`);
+    }
+    // If no package argument provided, implement new behavior for current project
+    if (!packageArgument) {
+        var _runConfig_unlink1, _runConfig_unlink2;
+        logger.info('UNLINK_SMART_MODE: Smart unlinking mode activated for current project | Mode: smart | Target: current directory | Purpose: Auto-unlink based on scope');
+        const currentDir = process.cwd();
+        const packageJsonPath = `${currentDir}/package.json`;
+        // Check if we're in a directory with package.json
+        if (!await storage.exists(packageJsonPath)) {
+            const message = `No package.json found in current directory: ${currentDir}`;
+            logger.warn('UNLINK_NO_PACKAGE_JSON: No package.json found in current directory | Directory: ' + currentDir + ' | Action: Cannot unlink without package.json');
+            return message;
+        }
+        // Parse package.json to get package name
+        let packageName;
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+            const packageJson = validatePackageJson(parsed, packageJsonPath);
+            if (!packageJson.name) {
+                throw new Error('package.json has no name field');
+            }
+            packageName = packageJson.name;
+        } catch (error) {
+            const message = `Failed to parse package.json: ${error.message}`;
+            logger.error('UNLINK_PACKAGE_NAME_MISSING: package.json must have a name field | Field: name | Requirement: Required for unlinking | Action: Add name field to package.json');
+            return message;
+        }
+        logger.info(`UNLINK_PACKAGE_PROCESSING: Processing package for unlinking | Package: ${packageName} | Action: Remove symlinks and restore registry versions`);
+        const cleanNodeModules = ((_runConfig_unlink1 = runConfig.unlink) === null || _runConfig_unlink1 === void 0 ? void 0 : _runConfig_unlink1.cleanNodeModules) || false;
+        const externalUnlinkPatterns = ((_runConfig_unlink2 = runConfig.unlink) === null || _runConfig_unlink2 === void 0 ? void 0 : _runConfig_unlink2.externals) || [];
+        // Step 0: Handle external dependencies if patterns are specified
+        if (externalUnlinkPatterns.length > 0) {
+            logger.info(`UNLINK_EXTERNAL_DEPS: Processing external dependencies | Patterns: ${externalUnlinkPatterns.join(', ')} | Purpose: Unlink external packages before main package`);
+            // Read package.json to get dependencies
+            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+            const packageJson = validatePackageJson(parsed, packageJsonPath);
+            const allDependencies = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies
+            };
+            const externalDependencies = Object.keys(allDependencies).filter((depName)=>matchesExternalUnlinkPattern(depName, externalUnlinkPatterns));
+            if (externalDependencies.length > 0) {
+                logger.info(`UNLINK_EXTERNAL_FOUND: Found external dependencies to unlink | Count: ${externalDependencies.length} | Dependencies: ${externalDependencies.join(', ')}`);
+                for (const depName of externalDependencies){
+                    try {
+                        const success = await removeSymbolicLink(depName, currentDir, logger, isDryRun);
+                        if (success) {
+                            logger.info(`UNLINK_EXTERNAL_SUCCESS: External dependency unlinked successfully | Dependency: ${depName} | Status: unlinked`);
+                        } else {
+                            logger.warn(`UNLINK_EXTERNAL_FAILED: Failed to unlink external dependency | Dependency: ${depName} | Status: failed`);
+                        }
+                    } catch (error) {
+                        logger.warn(`UNLINK_EXTERNAL_ERROR: Error during external dependency unlink | Dependency: ${depName} | Error: ${error.message}`);
+                    }
+                }
+            } else {
+                logger.info('UNLINK_EXTERNAL_NONE: No external dependencies found matching patterns | Patterns: ' + externalUnlinkPatterns.join(', ') + ' | Action: Skipping external unlink');
+            }
+        }
+        if (isDryRun) {
+            let dryRunMessage = `DRY RUN: Would execute unlink steps for ${packageName}:\n`;
+            if (externalUnlinkPatterns.length > 0) {
+                dryRunMessage += `  0. Unlink external dependencies matching patterns: ${externalUnlinkPatterns.join(', ')}\n`;
+            }
+            dryRunMessage += `  1. npm unlink -g\n`;
+            if (cleanNodeModules) {
+                dryRunMessage += `  2. rm -rf node_modules package-lock.json\n`;
+                dryRunMessage += `  3. npm install\n`;
+                dryRunMessage += `  4. Check for remaining links with npm ls --link`;
+            } else {
+                dryRunMessage += `  2. Check for remaining links with npm ls --link\n`;
+                dryRunMessage += `  Note: Use --clean-node-modules flag to also clean and reinstall dependencies`;
+            }
+            logger.info(dryRunMessage);
+            return dryRunMessage;
+        }
+        // Step 1: Remove global link
+        logger.info('UNLINK_GLOBAL_REMOVING: Removing global npm link | Step: 1 | Command: npm unlink -g | Purpose: Remove package from global npm');
+        try {
+            await run('npm unlink -g');
+            logger.info('UNLINK_GLOBAL_SUCCESS: Global link removed successfully | Status: unlinked | Location: global npm');
+        } catch (error) {
+            // This might fail if the package wasn't globally linked, which is OK
+            logger.warn(`UNLINK_GLOBAL_SKIP: Failed to remove global link | Error: ${error.message} | Impact: OK if package wasn't linked | Status: continuing`);
+        }
+        if (cleanNodeModules) {
+            // Step 2: Clean node_modules and package-lock.json
+            logger.info('UNLINK_CLEANING: Cleaning node_modules and package-lock.json | Command: rm -rf | Purpose: Remove symlinked dependencies');
+            try {
+                await run('rm -rf node_modules package-lock.json');
+                logger.info('UNLINK_CLEAN_SUCCESS: Successfully cleaned node_modules and package-lock.json | Status: removed | Next: Fresh install');
+            } catch (error) {
+                logger.warn(`UNLINK_CLEAN_FAILED: Failed to clean directories | Error: ${error.message} | Impact: May need manual cleanup`);
+            }
+            // Step 3: Install dependencies
+            logger.info('UNLINK_INSTALLING: Installing dependencies from registry | Command: npm install | Purpose: Restore registry versions');
+            try {
+                await run('npm install');
+                logger.info('UNLINK_INSTALL_SUCCESS: Dependencies installed successfully | Source: npm registry | Status: completed');
+            } catch (error) {
+                logger.error(`UNLINK_INSTALL_FAILED: Failed to install dependencies | Error: ${error.message} | Impact: Package may be in inconsistent state`);
+                throw error;
+            }
+            // Step 4: Check for remaining links (suppress output and errors)
+            logger.info('UNLINK_CHECK_REMAINING: Checking for remaining symlinks | Purpose: Verify clean unlink | Action: Scan node_modules');
+        } else {
+            // Step 2: Check for remaining links (suppress output and errors)
+            logger.info('UNLINK_CHECK_REMAINING: Checking for remaining symlinks | Mode: skip-reinstall | Purpose: Verify unlink | Action: Scan node_modules');
+            logger.info('Note: Use --clean-node-modules flag to also clean and reinstall dependencies');
+        }
+        try {
+            // Use child_process directly to suppress logging and get JSON output
+            const util = await import('util');
+            const child_process = await import('child_process');
+            const execPromise = util.promisify(child_process.exec);
+            const result = await execPromise('npm ls --link --json');
+            // Parse JSON output to check for links to packages in the same scope
+            const packageScope = packageName.includes('/') ? packageName.split('/')[0] : null;
+            if (packageScope && result.stdout.trim()) {
+                try {
+                    const linksData = safeJsonParse(result.stdout, 'npm ls output after unlink');
+                    const linkedPackages = Object.keys(linksData.dependencies || {});
+                    const scopeLinkedPackages = linkedPackages.filter((pkg)=>pkg.startsWith(packageScope + '/'));
+                    if (scopeLinkedPackages.length > 0) {
+                        logger.warn(`UNLINK_REMAINING_LINKS: Found remaining links to packages in scope | Scope: ${packageScope} | Packages: ${scopeLinkedPackages.join(', ')} | Note: May be expected if workspace packages linked`);
+                        logger.verbose('UNLINK_REMAINING_NOTE: Remaining links may be expected | Reason: Other workspace packages still linked | Status: normal');
+                    } else {
+                        logger.info('UNLINK_VERIFY_CLEAN: No problematic links found | Status: clean | Verification: passed');
+                    }
+                } catch  {
+                    // If JSON parsing fails, fall back to basic check
+                    logger.verbose('Failed to parse npm ls --link --json output, using basic check');
+                    if (result.stdout.includes(packageScope)) {
+                        logger.warn(`UNLINK_REMAINING_LINKS_BASIC: Found remaining links to scope | Scope: ${packageScope} | Check: basic | Note: May be expected`);
+                        logger.verbose('UNLINK_REMAINING_NOTE: Remaining links may be expected | Reason: Other workspace packages still linked | Status: normal');
+                    } else {
+                        logger.info('UNLINK_VERIFY_CLEAN: No problematic links found | Status: clean | Verification: passed');
+                    }
+                }
+            } else {
+                logger.info('UNLINK_VERIFY_CLEAN: No problematic links found | Status: clean | Verification: passed');
+            }
+        } catch  {
+            // npm ls --link returns non-zero when there are no links, which is what we want
+            // So we only log this at verbose level
+            logger.verbose('npm ls --link check completed (non-zero exit is expected when no links exist)');
+        }
+        const summary = `Successfully unlinked ${packageName}`;
+        logger.info(summary);
+        return summary;
+    }
+    // New scope-based unlinking behavior
+    logger.info(`UNLINK_EXPLICIT_MODE: Unlinking specific scope/package | Target: ${packageArgument} | Mode: explicit | Purpose: Remove symlinks for package`);
+    const { scope, packageName } = parsePackageArgument(packageArgument);
+    logger.verbose(`Parsed scope: ${scope}, package: ${packageName || 'all packages in scope'}`);
+    // Find matching packages in the workspace
+    const matchingPackages = await findMatchingPackages(targetDirectories, scope, storage, logger, packageName);
+    if (matchingPackages.length === 0) {
+        const message = packageName ? `No package found matching: ${packageName}` : `No packages found in scope: ${scope}`;
+        logger.warn(message);
+        return message;
+    }
+    logger.info(`Found ${matchingPackages.length} matching package(s)`);
+    const unlinkedPackages = [];
+    // If specific package name provided, use that; otherwise unlink all packages in scope
+    const packagesToUnlink = packageName ? matchingPackages.filter((pkg)=>pkg.name === packageName) : matchingPackages;
+    for (const pkg of packagesToUnlink){
+        logger.info(`Processing package: ${pkg.name}`);
+        // Step A: Find all packages that depend on this package and unlink them first
+        const consumingPackages = await findConsumingPackages(targetDirectories, pkg.name, storage, logger);
+        if (consumingPackages.length === 0) {
+            logger.info(`No consuming packages found for: ${pkg.name}`);
+        } else {
+            logger.info(`Found ${consumingPackages.length} consuming package(s) for: ${pkg.name}`);
+            for (const consumer of consumingPackages){
+                try {
+                    const consumerOriginalCwd = process.cwd();
+                    process.chdir(consumer.path);
+                    try {
+                        if (isDryRun) {
+                            logger.info(`DRY RUN: Would run 'npm unlink ${pkg.name}' in: ${consumer.path}`);
+                        } else {
+                            logger.verbose(`Running 'npm unlink ${pkg.name}' in consumer: ${consumer.path}`);
+                            await runSecure('npm', [
+                                'unlink',
+                                pkg.name
+                            ]);
+                            logger.info(`UNLINK_CONSUMER_SUCCESS: Consumer unlinked from package | Consumer: ${consumer.name} | Package: ${pkg.name} | Status: unlinked`);
+                        }
+                    } finally{
+                        process.chdir(consumerOriginalCwd);
+                    }
+                } catch (error) {
+                    // npm unlink can fail if package wasn't linked, but that's OK
+                    logger.warn(`UNLINK_CONSUMER_FAILED: Failed to unlink consumer | Consumer: ${consumer.name} | Package: ${pkg.name} | Error: ${error.message}`);
+                }
+            }
+        }
+        // Step B: Run 'npm unlink' in the source package directory
+        try {
+            const originalCwd = process.cwd();
+            process.chdir(pkg.path);
+            try {
+                if (isDryRun) {
+                    logger.info(`DRY RUN: Would run 'npm unlink' in: ${pkg.path}`);
+                } else {
+                    logger.verbose(`Running 'npm unlink' in source: ${pkg.path}`);
+                    await run('npm unlink');
+                    logger.info(`UNLINK_SOURCE_SUCCESS: Source package unlinked | Package: ${pkg.name} | Status: unlinked`);
+                }
+            } finally{
+                process.chdir(originalCwd);
+            }
+            unlinkedPackages.push(pkg.name);
+        } catch (error) {
+            // npm unlink can fail if package wasn't linked, but that's OK
+            logger.warn(`UNLINK_SOURCE_FAILED: Failed to unlink source package | Package: ${pkg.name} | Error: ${error.message}`);
+            unlinkedPackages.push(pkg.name); // Still count as success
+        }
+    }
+    const summary = `Successfully unlinked ${unlinkedPackages.length} package(s): ${unlinkedPackages.join(', ')}`;
+    logger.info(summary);
+    return summary;
+};
+// Status function to show what's currently linked (same as link command)
+const executeStatus = async (runConfig)=>{
+    var _runConfig_tree;
+    const logger = getLogger();
+    const storage = createStorage();
+    // Get target directories from config, default to current directory
+    const targetDirectories = ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.directories) || [
+        process.cwd()
+    ];
+    if (targetDirectories.length === 1) {
+        logger.info(`UNLINK_STATUS_CHECK: Checking link status in directory | Directory: ${targetDirectories[0]} | Purpose: Show current symlinks`);
+    } else {
+        logger.info(`UNLINK_STATUS_CHECK: Checking link status in directories | Directories: ${targetDirectories.join(', ')} | Count: ${targetDirectories.length} | Purpose: Show current symlinks`);
+    }
+    // Find all packages in the workspace
+    let allPackageJsonFiles = [];
+    for (const targetDirectory of targetDirectories){
+        const packageJsonFiles = await findAllPackageJsonFiles(targetDirectory, storage);
+        allPackageJsonFiles = allPackageJsonFiles.concat(packageJsonFiles);
+    }
+    const packageStatuses = [];
+    for (const packageJsonLocation of allPackageJsonFiles){
+        const packageDir = packageJsonLocation.path.replace('/package.json', '');
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonLocation.path, 'utf-8');
+            const parsed = safeJsonParse(packageJsonContent, packageJsonLocation.path);
+            const packageJson = validatePackageJson(parsed, packageJsonLocation.path);
+            if (!packageJson.name) continue;
+            const linkedDependencies = await findLinkedDependencies(packageDir, packageJson.name, storage, logger);
+            if (linkedDependencies.length > 0) {
+                packageStatuses.push({
+                    name: packageJson.name,
+                    path: packageDir,
+                    linkedDependencies
+                });
+            }
+        } catch (error) {
+            logger.warn(`Failed to parse ${packageJsonLocation.path}: ${error.message}`);
+        }
+    }
+    if (packageStatuses.length === 0) {
+        return 'No linked dependencies found in workspace.';
+    }
+    // Format the output
+    let output = `Found ${packageStatuses.length} package(s) with linked dependencies:\n\n`;
+    for (const packageStatus of packageStatuses){
+        output += `📦 ${packageStatus.name}\n`;
+        output += `   Path: ${packageStatus.path}\n`;
+        if (packageStatus.linkedDependencies.length > 0) {
+            output += `   Linked dependencies:\n`;
+            for (const dep of packageStatus.linkedDependencies){
+                const type = dep.isExternal ? '🔗 External' : '🔗 Internal';
+                output += `     ${type} ${dep.dependencyName} -> ${dep.targetPath}\n`;
+            }
+        }
+        output += '\n';
+    }
+    return output;
+};
+const execute$3 = async (runConfig, packageArgument)=>{
+    try {
+        var _runConfig_unlink;
+        // Check if this is a status command from direct parameter
+        if (packageArgument === 'status') {
+            return await executeStatus(runConfig);
+        }
+        // Use packageArgument from runConfig if not provided as parameter
+        const finalPackageArgument = packageArgument || ((_runConfig_unlink = runConfig.unlink) === null || _runConfig_unlink === void 0 ? void 0 : _runConfig_unlink.packageArgument);
+        // Check if this is a status command from config
+        if (finalPackageArgument === 'status') {
+            return await executeStatus(runConfig);
+        }
+        return await executeInternal(runConfig, finalPackageArgument);
+    } catch (error) {
+        const logger = getLogger();
+        logger.error(`unlink failed: ${error.message}`);
+        throw error;
+    }
+};
+
+/**
+ * Update inter-project dependencies in package.json based on current tree state
+ */ const updateInterProjectDependencies$1 = async (packageDir, scope, isDryRun, logger)=>{
+    const storage = createStorage();
+    const packageJsonPath = path.join(packageDir, 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        logger.verbose('No package.json found, skipping dependency updates');
+        return {
+            hasChanges: false,
+            updated: []
+        };
+    }
+    const updated = [];
+    let hasChanges = false;
+    try {
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const packageJson = safeJsonParse(packageJsonContent, packageJsonPath);
+        const sectionsToUpdate = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies'
+        ];
+        // Collect all dependencies matching the scope
+        const depsToUpdate = [];
+        for (const section of sectionsToUpdate){
+            const deps = packageJson[section];
+            if (deps) {
+                for (const [depName, depVersion] of Object.entries(deps)){
+                    if (depName.startsWith(scope)) {
+                        depsToUpdate.push({
+                            section,
+                            name: depName,
+                            currentVersion: depVersion
+                        });
+                    }
+                }
+            }
+        }
+        if (depsToUpdate.length === 0) {
+            logger.info(`UPDATES_NO_DEPS_FOUND: No dependencies matching scope | Scope: ${scope} | Package Dir: ${packageDir} | Status: No updates needed`);
+            return {
+                hasChanges: false,
+                updated: []
+            };
+        }
+        logger.info(`UPDATES_DEPS_FOUND: Found dependencies matching scope | Scope: ${scope} | Count: ${depsToUpdate.length} | Action: Will check and update versions`);
+        // For each dependency, find its package.json and get the current version
+        for (const dep of depsToUpdate){
+            try {
+                // Look for package in parent directories or node_modules
+                let depVersion = null;
+                // First try to find in tree (sibling packages)
+                const parentDir = path.dirname(packageDir);
+                const siblingPackageJson = path.join(parentDir, dep.name.split('/').pop(), 'package.json');
+                if (await storage.exists(siblingPackageJson)) {
+                    const siblingContent = await storage.readFile(siblingPackageJson, 'utf-8');
+                    const siblingPackage = safeJsonParse(siblingContent, siblingPackageJson);
+                    if (siblingPackage.name === dep.name) {
+                        depVersion = siblingPackage.version;
+                        logger.verbose(`Found ${dep.name}@${depVersion} in tree`);
+                    }
+                }
+                // Fall back to npm to get latest published version
+                if (!depVersion) {
+                    try {
+                        const { stdout } = await run(`npm view ${dep.name} version`);
+                        depVersion = stdout.trim();
+                        logger.verbose(`Found ${dep.name}@${depVersion} on npm`);
+                    } catch  {
+                        logger.warn(`UPDATES_VERSION_NOT_FOUND: Could not find version for dependency | Dependency: ${dep.name} | Action: Skipping | Reason: Not found in tree or npm`);
+                        continue;
+                    }
+                }
+                const newVersion = `^${depVersion}`;
+                if (dep.currentVersion !== newVersion) {
+                    if (isDryRun) {
+                        logger.info(`UPDATES_WOULD_UPDATE: Would update dependency | Mode: dry-run | Section: ${dep.section} | Dependency: ${dep.name} | Current: ${dep.currentVersion} | New: ${newVersion}`);
+                    } else {
+                        logger.info(`UPDATES_UPDATING: Updating dependency version | Section: ${dep.section} | Dependency: ${dep.name} | Current: ${dep.currentVersion} | New: ${newVersion}`);
+                        packageJson[dep.section][dep.name] = newVersion;
+                    }
+                    hasChanges = true;
+                    updated.push(`${dep.name}: ${dep.currentVersion} → ${newVersion}`);
+                }
+            } catch (error) {
+                logger.warn(`UPDATES_DEP_UPDATE_FAILED: Failed to update dependency | Dependency: ${dep.name} | Error: ${error.message}`);
+            }
+        }
+        if (hasChanges && !isDryRun) {
+            await storage.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+            logger.info(`UPDATES_PACKAGE_COMPLETE: Updated dependencies in package.json | Count: ${updated.length} | File: package.json | Status: saved`);
+        }
+    } catch (error) {
+        logger.warn(`UPDATES_INTER_PROJECT_FAILED: Failed to update inter-project dependencies | Error: ${error.message} | Impact: Dependencies not updated`);
+    }
+    return {
+        hasChanges,
+        updated
+    };
+};
+/**
+ * Execute the updates command
+ */ const execute$2 = async (runConfig)=>{
+    var _runConfig_updates, _runConfig_updates1, _runConfig_tree;
+    const isDryRun = runConfig.dryRun || false;
+    const logger = getDryRunLogger(isDryRun);
+    // Check if this is inter-project mode
+    const interProjectMode = ((_runConfig_updates = runConfig.updates) === null || _runConfig_updates === void 0 ? void 0 : _runConfig_updates.interProject) || false;
+    if (interProjectMode) {
+        var _runConfig_updates2;
+        // Inter-project dependency update mode
+        const scope = (_runConfig_updates2 = runConfig.updates) === null || _runConfig_updates2 === void 0 ? void 0 : _runConfig_updates2.scope;
+        if (!scope) {
+            throw new Error('Scope parameter is required for inter-project updates. Usage: kodrdriv updates --inter-project <scope>');
+        }
+        if (!scope.startsWith('@')) {
+            throw new Error(`Invalid scope "${scope}". Scope must start with @ (e.g., "@fjell")`);
+        }
+        logger.info(`UPDATES_INTER_PROJECT_STARTING: Updating inter-project dependencies | Scope: ${scope} | Type: inter-project | Purpose: Sync dependency versions`);
+        const result = await updateInterProjectDependencies$1(process.cwd(), scope, isDryRun, logger);
+        if (result.hasChanges && !isDryRun) {
+            logger.info('UPDATES_NPM_INSTALL: Running npm install to update lock file | Command: npm install | Purpose: Synchronize package-lock.json with changes');
+            try {
+                await run('npm install');
+                logger.info('UPDATES_LOCK_FILE_UPDATED: Lock file updated successfully | File: package-lock.json | Status: synchronized');
+            } catch (error) {
+                logger.error(`UPDATES_NPM_INSTALL_FAILED: Failed to run npm install | Error: ${error.message} | Impact: Lock file not updated`);
+                throw new Error(`Failed to update lock file: ${error.message}`);
+            }
+        }
+        if (result.updated.length > 0) {
+            logger.info(`UPDATES_INTER_PROJECT_COMPLETE: Updated inter-project dependencies | Count: ${result.updated.length} | Status: completed`);
+            result.updated.forEach((update)=>logger.info(`UPDATES_DEP_UPDATED: ${update}`));
+        } else {
+            logger.info('UPDATES_INTER_PROJECT_NONE: No inter-project dependency updates needed | Status: All dependencies current');
+        }
+        return `Updated ${result.updated.length} inter-project dependencies`;
+    }
+    // Original scope-based npm-check-updates mode
+    const scope = ((_runConfig_updates1 = runConfig.updates) === null || _runConfig_updates1 === void 0 ? void 0 : _runConfig_updates1.scope) || ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.packageArgument);
+    if (!scope) {
+        throw new Error('Scope parameter is required. Usage: kodrdriv updates <scope> or kodrdriv updates --inter-project <scope>');
+    }
+    // Validate that scope looks like a valid npm scope (starts with @)
+    if (!scope.startsWith('@')) {
+        throw new Error(`Invalid scope "${scope}". Scope must start with @ (e.g., "@fjell")`);
+    }
+    logger.info(`UPDATES_NCU_STARTING: Running npm-check-updates for scope | Scope: ${scope} | Tool: npm-check-updates | Purpose: Find outdated dependencies`);
+    // Build the npm-check-updates command
+    const ncuCommand = `npx npm-check-updates '/${scope.replace('@', '^@')}//' -u`;
+    logger.info(`UPDATES_NCU_EXECUTING: Executing npm-check-updates command | Command: ${ncuCommand} | Scope: ${scope}`);
+    try {
+        if (isDryRun) {
+            logger.info(`Would run: ${ncuCommand}`);
+            logger.info('Would run: npm install');
+            return `Would update dependencies matching ${scope} scope`;
+        }
+        // Execute npm-check-updates
+        const result = await run(ncuCommand);
+        if (result.stdout) {
+            logger.info('UPDATES_NCU_OUTPUT: npm-check-updates output | Status: completed');
+            result.stdout.split('\n').forEach((line)=>{
+                if (line.trim()) {
+                    logger.info(`   ${line}`);
+                }
+            });
+        }
+        if (result.stderr) {
+            logger.info('UPDATES_NCU_WARNINGS: npm-check-updates produced warnings | Type: warnings');
+            result.stderr.split('\n').forEach((line)=>{
+                if (line.trim()) {
+                    logger.info(`   ${line}`);
+                }
+            });
+        }
+        // Check if package.json was actually modified
+        const hasUpdates = result.stdout && !result.stdout.includes('All dependencies match the latest package versions');
+        if (hasUpdates) {
+            logger.info('UPDATES_NCU_INSTALL: Running npm install after ncu updates | Command: npm install | Purpose: Update lock file with new versions');
+            try {
+                const installResult = await run('npm install');
+                if (installResult.stdout) {
+                    logger.verbose('npm install output:');
+                    installResult.stdout.split('\n').forEach((line)=>{
+                        if (line.trim()) {
+                            logger.verbose(`   ${line}`);
+                        }
+                    });
+                }
+                logger.info('UPDATES_NCU_LOCK_UPDATED: Lock file updated successfully after ncu | File: package-lock.json | Status: synchronized');
+            } catch (installError) {
+                logger.error(`UPDATES_NCU_INSTALL_FAILED: Failed to run npm install after ncu | Error: ${installError.message} | Impact: Lock file not synchronized`);
+                throw new Error(`Failed to update lock file after dependency updates: ${installError.message}`);
+            }
+        }
+        logger.info(`UPDATES_NCU_SUCCESS: Successfully updated dependencies | Scope: ${scope} | Status: completed | Files: package.json, package-lock.json`);
+        return `Updated dependencies matching ${scope} scope`;
+    } catch (error) {
+        logger.error(`UPDATES_NCU_FAILED: Failed to run npm-check-updates | Scope: ${scope} | Error: ${error.message} | Impact: Dependencies not updated`);
+        throw new Error(`Failed to update dependencies: ${error.message}`);
+    }
+};
+
+// Global state to track published versions during tree execution - protected by mutex
+let publishedVersions = [];
+let executionContext = null;
+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 = createStorage();
+    const packageJsonPath = path.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;
+            }
+            // Skip prerelease versions (e.g., 1.0.0-beta.1, 2.0.0-alpha.3)
+            // Prerelease versions should not be automatically propagated to consumers
+            if (version.includes('-')) {
+                packageLogger.verbose(`Skipping prerelease version ${packageName}@${version} - not updating dependencies`);
+                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;
+};
+// Detect scoped dependencies from package.json and run updates for them
+const updateScopedDependencies = async (packageDir, packageLogger, isDryRun, runConfig)=>{
+    const storage = createStorage();
+    const packageJsonPath = path.join(packageDir, 'package.json');
+    if (!await storage.exists(packageJsonPath)) {
+        packageLogger.verbose('No package.json found, skipping scoped dependency updates');
+        return false;
+    }
+    try {
+        var _runConfig_publish;
+        // Read the package.json before updates
+        const beforeContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(beforeContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        // Determine which scopes to update
+        let scopesToUpdate;
+        // Check if scopedDependencyUpdates is configured
+        const configuredScopes = (_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.scopedDependencyUpdates;
+        if (configuredScopes !== undefined) {
+            // scopedDependencyUpdates is explicitly configured
+            if (configuredScopes.length > 0) {
+                // Use configured scopes
+                scopesToUpdate = new Set(configuredScopes);
+                packageLogger.verbose(`Using configured scopes: ${Array.from(scopesToUpdate).join(', ')}`);
+            } else {
+                // Empty array means explicitly disabled
+                packageLogger.verbose('Scoped dependency updates explicitly disabled');
+                return false;
+            }
+        } else {
+            // Not configured - use default behavior (package's own scope)
+            scopesToUpdate = new Set();
+            if (packageJson.name && packageJson.name.startsWith('@')) {
+                const packageScope = packageJson.name.split('/')[0]; // e.g., "@fjell/core" -> "@fjell"
+                scopesToUpdate.add(packageScope);
+                packageLogger.verbose(`No scopes configured, defaulting to package's own scope: ${packageScope}`);
+            } else {
+                packageLogger.verbose('Package is not scoped and no scopes configured, skipping scoped dependency updates');
+                return false;
+            }
+        }
+        if (scopesToUpdate.size === 0) {
+            packageLogger.verbose('No scopes to update, skipping updates');
+            return false;
+        }
+        // Run updates for each scope
+        for (const scope of scopesToUpdate){
+            packageLogger.info(`🔄 Checking for ${scope} dependency updates before publish...`);
+            try {
+                // Create a config for the updates command with the scope
+                const updatesConfig = {
+                    ...runConfig,
+                    dryRun: isDryRun,
+                    updates: {
+                        scope: scope
+                    }
+                };
+                await execute$2(updatesConfig);
+            } catch (error) {
+                // Don't fail the publish if updates fails, just warn
+                packageLogger.warn(`Failed to update ${scope} dependencies: ${error.message}`);
+            }
+        }
+        // Check if package.json was modified
+        const afterContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const hasChanges = beforeContent !== afterContent;
+        if (hasChanges) {
+            packageLogger.info('✅ Scoped dependencies updated successfully');
+        } else {
+            packageLogger.info('No scoped dependency updates needed');
+        }
+        return hasChanges;
+    } catch (error) {
+        packageLogger.warn(`Failed to detect scoped dependencies: ${error.message}`);
+        return false;
+    }
+};
+// 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 = createStorage(); // Silent storage for context operations
+    const contextFilePath = getContextFilePath(outputDirectory);
+    try {
+        // Ensure output directory exists
+        await storage.ensureDirectory(path.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 = createStorage(); // 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 = createStorage(); // 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}`);
+    }
+};
+// Helper function to promote a package to completed status in the context
+const promotePackageToCompleted = async (packageName, outputDirectory)=>{
+    const storage = createStorage();
+    const contextFilePath = getContextFilePath(outputDirectory);
+    try {
+        if (!await storage.exists(contextFilePath)) {
+            return;
+        }
+        const contextContent = await storage.readFile(contextFilePath, 'utf-8');
+        const contextData = safeJsonParse(contextContent, contextFilePath);
+        // Restore dates from ISO strings
+        const context = {
+            ...contextData,
+            startTime: new Date(contextData.startTime),
+            lastUpdateTime: new Date(contextData.lastUpdateTime),
+            publishedVersions: contextData.publishedVersions.map((v)=>({
+                    ...v,
+                    publishTime: new Date(v.publishTime)
+                }))
+        };
+        // Add package to completed list if not already there
+        if (!context.completedPackages.includes(packageName)) {
+            context.completedPackages.push(packageName);
+            context.lastUpdateTime = new Date();
+            await saveExecutionContext(context, outputDirectory);
+        }
+    } catch (error) {
+        const logger = getLogger();
+        logger.warn(`Warning: Failed to promote package to completed: ${error.message}`);
+    }
+};
+// Helper function to validate that all packages have the required scripts
+const validateScripts = async (packages, scripts)=>{
+    const logger = getLogger();
+    const missingScripts = new Map();
+    const storage = createStorage();
+    logger.debug(`Validating scripts: ${scripts.join(', ')}`);
+    for (const [packageName, packageInfo] of packages){
+        const packageJsonPath = path.join(packageInfo.path, 'package.json');
+        const missingForPackage = [];
+        try {
+            const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+            const packageJson = safeJsonParse(packageJsonContent, packageJsonPath);
+            const validated = validatePackageJson(packageJson, packageJsonPath);
+            // Check if each required script exists
+            for (const script of scripts){
+                if (!validated.scripts || !validated.scripts[script]) {
+                    missingForPackage.push(script);
+                }
+            }
+            if (missingForPackage.length > 0) {
+                missingScripts.set(packageName, missingForPackage);
+                logger.debug(`Package ${packageName} missing scripts: ${missingForPackage.join(', ')}`);
+            }
+        } catch (error) {
+            logger.debug(`Error reading package.json for ${packageName}: ${error.message}`);
+            // If we can't read the package.json, assume all scripts are missing
+            missingScripts.set(packageName, scripts);
+        }
+    }
+    const valid = missingScripts.size === 0;
+    if (valid) {
+        logger.info(`✅ All packages have the required scripts: ${scripts.join(', ')}`);
+    } else {
+        logger.error(`❌ Script validation failed. Missing scripts:`);
+        for (const [packageName, missing] of missingScripts){
+            logger.error(`  ${packageName}: ${missing.join(', ')}`);
+        }
+    }
+    return {
+        valid,
+        missingScripts
+    };
+};
+// Extract published version from git tags after successful publish
+// After kodrdriv publish, the release version is captured in the git tag,
+// while package.json contains the next dev version
+const extractPublishedVersion = async (packageDir, packageLogger)=>{
+    const storage = createStorage();
+    const packageJsonPath = path.join(packageDir, 'package.json');
+    try {
+        // Get package name from package.json
+        const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageJsonPath);
+        // Get the most recently created tag (by creation date, not version number)
+        // This ensures we get the tag that was just created by the publish, not an older tag with a higher version
+        const { stdout: tagOutput } = await run('git tag --sort=-creatordate', {
+            cwd: packageDir
+        });
+        const tags = tagOutput.trim().split('\n').filter(Boolean);
+        if (tags.length === 0) {
+            packageLogger.warn('No git tags found after publish');
+            return null;
+        }
+        // Get the most recently created tag (first in the list)
+        const latestTag = tags[0];
+        // Extract version from tag, handling various formats:
+        // - v1.2.3 -> 1.2.3
+        // - working/v1.2.3 -> 1.2.3
+        // - main/v1.2.3 -> 1.2.3
+        let version = latestTag;
+        // If tag contains a slash (branch prefix), extract everything after it
+        if (version.includes('/')) {
+            version = version.split('/').pop() || version;
+        }
+        // Remove 'v' prefix if present
+        if (version.startsWith('v')) {
+            version = version.substring(1);
+        }
+        packageLogger.verbose(`Extracted published version from tag: ${latestTag} -> ${version}`);
+        return {
+            packageName: packageJson.name,
+            version: 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', logFilePath)=>{
+    const execPromise = util.promisify(exec);
+    // Ensure encoding is set to 'utf8' to get string output instead of Buffer
+    const execOptions = {
+        encoding: 'utf8',
+        ...options
+    };
+    if (showOutput === 'full') {
+        packageLogger.debug(`Executing command: ${command}`);
+        // Use info level to show on console in debug mode
+        packageLogger.info(`🔧 Running: ${command}`);
+    } else if (showOutput === 'minimal') {
+        packageLogger.verbose(`Running: ${command}`);
+    }
+    // Helper to write to log file
+    const writeToLogFile = async (content)=>{
+        if (!logFilePath) return;
+        try {
+            const logDir = path.dirname(logFilePath);
+            await fs.mkdir(logDir, {
+                recursive: true
+            });
+            await fs.appendFile(logFilePath, content + '\n', 'utf-8');
+        } catch (err) {
+            packageLogger.warn(`Failed to write to log file ${logFilePath}: ${err.message}`);
+        }
+    };
+    // Write command to log file
+    if (logFilePath) {
+        const timestamp = new Date().toISOString();
+        await writeToLogFile(`[${timestamp}] Executing: ${command}\n`);
+    }
+    try {
+        const result = await execPromise(command, execOptions);
+        if (showOutput === 'full') {
+            const stdout = String(result.stdout);
+            const stderr = String(result.stderr);
+            if (stdout.trim()) {
+                packageLogger.debug('STDOUT:');
+                packageLogger.debug(stdout);
+                // Show on console using info level for immediate feedback
+                packageLogger.info(`📤 STDOUT:`);
+                stdout.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+            if (stderr.trim()) {
+                packageLogger.debug('STDERR:');
+                packageLogger.debug(stderr);
+                // Show on console using info level for immediate feedback
+                packageLogger.info(`⚠️  STDERR:`);
+                stderr.split('\n').forEach((line)=>{
+                    if (line.trim()) packageLogger.info(`${line}`);
+                });
+            }
+        }
+        // Write output to log file
+        if (logFilePath) {
+            const stdout = String(result.stdout);
+            const stderr = String(result.stderr);
+            if (stdout.trim()) {
+                await writeToLogFile(`\n=== STDOUT ===\n${stdout}`);
+            }
+            if (stderr.trim()) {
+                await writeToLogFile(`\n=== STDERR ===\n${stderr}`);
+            }
+            await writeToLogFile(`\n[${new Date().toISOString()}] Command completed successfully\n`);
+        }
+        // Ensure result is properly typed as strings
+        return {
+            stdout: String(result.stdout),
+            stderr: String(result.stderr)
+        };
+    } catch (error) {
+        // Always show error message
+        packageLogger.error(`Command failed: ${command}`);
+        // Always show stderr on failure (contains important error details like coverage failures)
+        if (error.stderr && error.stderr.trim()) {
+            packageLogger.error(`❌ STDERR:`);
+            error.stderr.split('\n').forEach((line)=>{
+                if (line.trim()) packageLogger.error(`${line}`);
+            });
+        }
+        // Show stdout on failure if available (may contain error context)
+        if (error.stdout && error.stdout.trim() && (showOutput === 'full' || showOutput === 'minimal')) {
+            packageLogger.info(`📤 STDOUT:`);
+            error.stdout.split('\n').forEach((line)=>{
+                if (line.trim()) packageLogger.info(`${line}`);
+            });
+        }
+        // Show full output in debug/verbose mode
+        if (showOutput === 'full' || showOutput === 'minimal') {
+            if (error.stdout && error.stdout.trim() && showOutput === 'full') {
+                packageLogger.debug('STDOUT:');
+                packageLogger.debug(error.stdout);
+            }
+            if (error.stderr && error.stderr.trim() && showOutput === 'full') {
+                packageLogger.debug('STDERR:');
+                packageLogger.debug(error.stderr);
+            }
+        }
+        // Write error output to log file
+        if (logFilePath) {
+            await writeToLogFile(`\n[${new Date().toISOString()}] Command failed: ${error.message}`);
+            if (error.stdout) {
+                await writeToLogFile(`\n=== STDOUT ===\n${error.stdout}`);
+            }
+            if (error.stderr) {
+                await writeToLogFile(`\n=== STDERR ===\n${error.stderr}`);
+            }
+            if (error.stack) {
+                await writeToLogFile(`\n=== STACK TRACE ===\n${error.stack}`);
+            }
+        }
+        throw error;
+    }
+};
+// Create a package-scoped logger that prefixes all messages
+const createPackageLogger = (packageName, sequenceNumber, totalCount, isDryRun = false)=>{
+    const baseLogger = getLogger();
+    const prefix = `[${sequenceNumber}/${totalCount}] ${packageName}:`;
+    const dryRunPrefix = isDryRun ? 'DRY RUN: ' : '';
+    return {
+        info: (message, ...args)=>baseLogger.info(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        warn: (message, ...args)=>baseLogger.warn(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        error: (message, ...args)=>baseLogger.error(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        debug: (message, ...args)=>baseLogger.debug(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        verbose: (message, ...args)=>baseLogger.verbose(`${dryRunPrefix}${prefix} ${message}`, ...args),
+        silly: (message, ...args)=>baseLogger.silly(`${dryRunPrefix}${prefix} ${message}`, ...args)
+    };
+};
+// Helper function to format subproject error output
+const formatSubprojectError = (packageName, error, _packageInfo, _position, _total)=>{
+    const lines = [];
+    lines.push(`❌ Command failed in package ${packageName}:`);
+    // Format the main error message with indentation
+    if (error.message) {
+        const indentedMessage = error.message.split('\n').map((line)=>`    ${line}`).join('\n');
+        lines.push(indentedMessage);
+    }
+    // If there's stderr output, show it indented as well
+    if (error.stderr && error.stderr.trim()) {
+        lines.push('    STDERR:');
+        const indentedStderr = error.stderr.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStderr);
+    }
+    // If there's stdout output, show it indented as well
+    if (error.stdout && error.stdout.trim()) {
+        lines.push('    STDOUT:');
+        const indentedStdout = error.stdout.split('\n').filter((line)=>line.trim()).map((line)=>`      ${line}`).join('\n');
+        lines.push(indentedStdout);
+    }
+    return lines.join('\n');
+};
+// Note: PackageInfo, DependencyGraph, scanForPackageJsonFiles, parsePackageJson,
+// buildDependencyGraph, and topologicalSort are now imported from ../util/dependencyGraph
+// 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);
+    const packageDir = packageInfo.path;
+    const logger = getLogger();
+    // Create log file path for publish commands
+    let logFilePath;
+    if (isBuiltInCommand && commandToRun.includes('publish')) {
+        var _commandToRun_split_;
+        const outputDir = runConfig.outputDirectory || 'output/kodrdriv';
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').split('.')[0];
+        const commandName = ((_commandToRun_split_ = commandToRun.split(' ')[1]) === null || _commandToRun_split_ === void 0 ? void 0 : _commandToRun_split_.split(' ')[0]) || 'command';
+        logFilePath = path.join(packageDir, outputDir, `${commandName}_${timestamp}.log`);
+    }
+    // Determine output level based on flags
+    // For publish and commit commands, default to full output to show AI progress and other details
+    // For other commands, require --verbose or --debug for output
+    const isPublishCommand = isBuiltInCommand && commandToRun.includes('publish');
+    const isCommitCommand = isBuiltInCommand && commandToRun.includes('commit');
+    let showOutput = isPublishCommand || isCommitCommand ? 'full' : 'none';
+    if (runConfig.debug) {
+        showOutput = 'full';
+    } else if (runConfig.verbose) {
+        showOutput = 'minimal';
+    }
+    // Show package start info - always visible for progress tracking
+    if (runConfig.debug) {
+        packageLogger.debug('MULTI_PROJECT_START: Starting package execution | Package: %s | Index: %d/%d | Path: %s | Command: %s | Context: tree execution', packageName, index + 1, total, packageDir, commandToRun);
+        packageLogger.debug('MULTI_PROJECT_CONTEXT: Execution details | Directory: %s | Built-in Command: %s | Dry Run: %s | Output Level: %s', packageDir, isBuiltInCommand, isDryRun, showOutput);
+        // Show dependencies if available
+        if (packageInfo.dependencies && Array.isArray(packageInfo.dependencies) && packageInfo.dependencies.length > 0) {
+            packageLogger.debug('MULTI_PROJECT_DEPS: Package dependencies | Package: %s | Dependencies: [%s]', packageName, packageInfo.dependencies.join(', '));
+        }
+    } else if (runConfig.verbose) {
+        packageLogger.verbose(`Starting execution in ${packageDir}`);
+    } else {
+        // Basic progress info even without flags
+        logger.info(`[${index + 1}/${total}] ${packageName}: Running ${commandToRun}...`);
+    }
+    // Track if publish was skipped due to no changes
+    let publishWasSkipped = false;
+    // Track execution timing
+    const executionTimer = PerformanceTimer.start(packageLogger, `Package ${packageName} execution`);
+    let executionDuration;
+    try {
+        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;
+                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) {
+                packageLogger.info(`In directory: ${packageDir}`);
+            }
+        } else {
+            // 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.access(packageDir);
+                    const stat = await fs.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 dependency updates for publish commands before executing (skip during dry run)
+                // Wrap in git lock to prevent parallel packages from conflicting with npm install and git operations
+                if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish')) {
+                    await runGitWithLock(packageDir, async ()=>{
+                        let hasAnyUpdates = false;
+                        // First, update all scoped dependencies from npm registry
+                        const hasScopedUpdates = await updateScopedDependencies(packageDir, packageLogger, isDryRun, runConfig);
+                        hasAnyUpdates = hasAnyUpdates || hasScopedUpdates;
+                        // Then update inter-project dependencies based on previously published packages
+                        if (publishedVersions.length > 0) {
+                            packageLogger.info('Updating inter-project dependencies based on previously published packages...');
+                            const hasInterProjectUpdates = await updateInterProjectDependencies(packageDir, publishedVersions, allPackageNames, packageLogger, isDryRun);
+                            hasAnyUpdates = hasAnyUpdates || hasInterProjectUpdates;
+                        }
+                        // If either type of update occurred, commit the changes
+                        if (hasAnyUpdates) {
+                            // Commit the dependency updates using kodrdriv commit
+                            packageLogger.info('Committing dependency updates...');
+                            packageLogger.info('⏱️  This step may take a few minutes as it generates a commit message using AI...');
+                            // Add timeout wrapper around commit execution
+                            const commitTimeoutMs = 300000; // 5 minutes
+                            const commitPromise = Commit.commit({
+                                ...runConfig,
+                                dryRun: false
+                            });
+                            const timeoutPromise = new Promise((_, reject)=>{
+                                setTimeout(()=>reject(new Error(`Commit operation timed out after ${commitTimeoutMs / 1000} seconds`)), commitTimeoutMs);
+                            });
+                            // Add progress indicator
+                            let progressInterval = null;
+                            try {
+                                // Start progress indicator
+                                progressInterval = setInterval(()=>{
+                                    packageLogger.info('⏳ Still generating commit message... (this can take 1-3 minutes)');
+                                }, 30000); // Every 30 seconds
+                                await Promise.race([
+                                    commitPromise,
+                                    timeoutPromise
+                                ]);
+                                packageLogger.info('✅ Dependency updates committed successfully');
+                            } catch (commitError) {
+                                if (commitError.message.includes('timed out')) {
+                                    packageLogger.error(`❌ Commit operation timed out after ${commitTimeoutMs / 1000} seconds`);
+                                    packageLogger.error('This usually indicates an issue with the AI service or very large changes');
+                                    packageLogger.error('You may need to manually commit the dependency updates');
+                                } else {
+                                    packageLogger.warn(`Failed to commit dependency updates: ${commitError.message}`);
+                                }
+                            // Continue with publish anyway - the updates are still in place
+                            } finally{
+                                if (progressInterval) {
+                                    clearInterval(progressInterval);
+                                }
+                            }
+                        }
+                    }, `${packageName}: dependency updates`);
+                }
+                // Optimize precommit commands for custom commands (not built-in)
+                let effectiveCommandToRun = commandToRun;
+                let optimizationInfo = null;
+                if (!isBuiltInCommand && !isDryRun) {
+                    const isPrecommitCommand = commandToRun.includes('precommit') || commandToRun.includes('pre-commit');
+                    if (isPrecommitCommand) {
+                        try {
+                            const optimization = await optimizePrecommitCommand(packageDir, commandToRun);
+                            effectiveCommandToRun = optimization.optimizedCommand;
+                            optimizationInfo = {
+                                skipped: optimization.skipped,
+                                reasons: optimization.reasons
+                            };
+                            if (optimization.skipped.clean || optimization.skipped.test) {
+                                const skippedParts = [];
+                                if (optimization.skipped.clean) {
+                                    skippedParts.push(`clean (${optimization.reasons.clean})`);
+                                }
+                                if (optimization.skipped.test) {
+                                    skippedParts.push(`test (${optimization.reasons.test})`);
+                                }
+                                packageLogger.info(`⚡ Optimized: Skipped ${skippedParts.join(', ')}`);
+                                if (runConfig.verbose || runConfig.debug) {
+                                    packageLogger.info(`   Original: ${commandToRun}`);
+                                    packageLogger.info(`   Optimized: ${effectiveCommandToRun}`);
+                                }
+                            }
+                        } catch (error) {
+                            // If optimization fails, fall back to original command
+                            logger.debug(`Precommit optimization failed for ${packageName}: ${error.message}`);
+                        }
+                    }
+                }
+                if (runConfig.debug || runConfig.verbose) {
+                    if (isBuiltInCommand) {
+                        packageLogger.info(`Executing built-in command: ${commandToRun}`);
+                    } else {
+                        packageLogger.info(`Executing command: ${effectiveCommandToRun}`);
+                    }
+                }
+                // For built-in commands, shell out to a separate kodrdriv process
+                // This preserves individual project configurations
+                if (isBuiltInCommand) {
+                    // Extract the command name from "kodrdriv <command> [args...]"
+                    // Split by space and take the second element (after "kodrdriv")
+                    const commandParts = commandToRun.replace(/^kodrdriv\s+/, '').split(/\s+/);
+                    const builtInCommandName = commandParts[0];
+                    if (runConfig.debug) {
+                        packageLogger.debug(`Shelling out to separate kodrdriv process for ${builtInCommandName} command`);
+                    }
+                    // Add progress indication for publish commands
+                    if (builtInCommandName === 'publish') {
+                        packageLogger.info('🚀 Starting publish process...');
+                        packageLogger.info('⏱️  This may take several minutes (AI processing, PR creation, etc.)');
+                    }
+                    // Ensure dry-run propagates to subprocess even during overall dry-run mode
+                    let effectiveCommand = runConfig.dryRun && !commandToRun.includes('--dry-run') ? `${commandToRun} --dry-run` : commandToRun;
+                    // For commit commands, ensure --sendit is used to avoid interactive prompts
+                    // This prevents hanging when running via tree command
+                    if (builtInCommandName === 'commit' && !effectiveCommand.includes('--sendit') && !runConfig.dryRun) {
+                        effectiveCommand = `${effectiveCommand} --sendit`;
+                        packageLogger.info('💡 Auto-adding --sendit flag to avoid interactive prompts in tree mode');
+                    }
+                    // Set timeout based on command type
+                    let commandTimeoutMs;
+                    if (builtInCommandName === 'publish') {
+                        commandTimeoutMs = 1800000; // 30 minutes for publish commands
+                        packageLogger.info(`⏰ Setting timeout of ${commandTimeoutMs / 60000} minutes for publish command`);
+                    } else if (builtInCommandName === 'commit') {
+                        commandTimeoutMs = 600000; // 10 minutes for commit commands (AI processing can take time)
+                        packageLogger.info(`⏰ Setting timeout of ${commandTimeoutMs / 60000} minutes for commit command`);
+                    } else {
+                        commandTimeoutMs = 300000; // 5 minutes default for other commands
+                    }
+                    const commandPromise = runWithLogging(effectiveCommand, packageLogger, {}, showOutput, logFilePath);
+                    const commandTimeoutPromise = new Promise((_, reject)=>{
+                        setTimeout(()=>reject(new Error(`Command timed out after ${commandTimeoutMs / 60000} minutes`)), commandTimeoutMs);
+                    });
+                    try {
+                        const startTime = Date.now();
+                        const { stdout, stderr } = await Promise.race([
+                            commandPromise,
+                            commandTimeoutPromise
+                        ]);
+                        executionDuration = Date.now() - startTime;
+                        // Detect explicit skip marker from publish to avoid propagating versions
+                        // Check both stdout (where we now write it) and stderr (winston logger output, for backward compat)
+                        if (builtInCommandName === 'publish' && (stdout && stdout.includes('KODRDRIV_PUBLISH_SKIPPED') || stderr && stderr.includes('KODRDRIV_PUBLISH_SKIPPED'))) {
+                            packageLogger.info('Publish skipped for this package; will not record or propagate a version.');
+                            publishWasSkipped = true;
+                        }
+                    } catch (error) {
+                        if (error.message.includes('timed out')) {
+                            packageLogger.error(`❌ ${builtInCommandName} command timed out after ${commandTimeoutMs / 60000} minutes`);
+                            packageLogger.error('This usually indicates the command is stuck waiting for user input or an external service');
+                            throw error;
+                        }
+                        throw error;
+                    }
+                } else {
+                    // For custom commands, use the existing logic
+                    const startTime = Date.now();
+                    await runWithLogging(effectiveCommandToRun, packageLogger, {}, showOutput, logFilePath);
+                    executionDuration = Date.now() - startTime;
+                }
+                // Track published version after successful publish (skip during dry run)
+                if (!isDryRun && isBuiltInCommand && commandToRun.includes('publish')) {
+                    // If publish was skipped, do not record a version
+                    if (publishWasSkipped) {
+                        packageLogger.verbose('Skipping version tracking due to earlier skip.');
+                    } else {
+                        // Only record a published version if a new tag exists (avoid recording for skipped publishes)
+                        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;
+                            }
+                        }
+                    }
+                }
+                // Record test run if tests were executed (not skipped)
+                if (!isDryRun && !isBuiltInCommand && effectiveCommandToRun.includes('test') && (!optimizationInfo || !optimizationInfo.skipped.test)) {
+                    try {
+                        await recordTestRun(packageDir);
+                    } catch (error) {
+                        logger.debug(`Failed to record test run for ${packageName}: ${error.message}`);
+                    }
+                }
+                // End timing and show duration
+                if (executionDuration !== undefined) {
+                    executionTimer.end(`Package ${packageName} execution`);
+                    const seconds = (executionDuration / 1000).toFixed(1);
+                    if (runConfig.debug || runConfig.verbose) {
+                        packageLogger.info(`⏱️  Execution time: ${seconds}s`);
+                    } else if (!isPublishCommand && !isCommitCommand) {
+                        // Show timing in completion message (publish/commit commands have their own completion message)
+                        logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed (${seconds}s)`);
+                    }
+                } else {
+                    executionTimer.end(`Package ${packageName} execution`);
+                    if (runConfig.debug || runConfig.verbose) {
+                        packageLogger.info(`Command completed successfully`);
+                    } else if (!isPublishCommand && !isCommitCommand) {
+                        // Basic completion info (publish/commit commands have their own completion message)
+                        logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed`);
+                    }
+                }
+            } finally{
+                // 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
+                }
+            }
+        }
+        // Show completion status (for publish/commit commands, this supplements the timing message above)
+        if (runConfig.debug || runConfig.verbose) {
+            if (publishWasSkipped) {
+                packageLogger.info(`⊘ Skipped (no code changes)`);
+            } else {
+                packageLogger.info(`✅ Completed successfully`);
+            }
+        } else if (isPublishCommand || isCommitCommand) {
+            // For publish/commit commands, always show completion even without verbose
+            // Include timing if available
+            const timeStr = executionDuration !== undefined ? ` (${(executionDuration / 1000).toFixed(1)}s)` : '';
+            if (publishWasSkipped) {
+                logger.info(`[${index + 1}/${total}] ${packageName}: ⊘ Skipped (no code changes)`);
+            } else {
+                logger.info(`[${index + 1}/${total}] ${packageName}: ✅ Completed${timeStr}`);
+            }
+        }
+        // Ensure timing is recorded even if there was an early return
+        if (executionDuration === undefined) {
+            executionDuration = executionTimer.end(`Package ${packageName} execution`);
+        }
+        return {
+            success: true,
+            skippedNoChanges: publishWasSkipped,
+            logFile: logFilePath
+        };
+    } catch (error) {
+        var _error_message;
+        // Record timing even on error
+        if (executionDuration === undefined) {
+            executionDuration = executionTimer.end(`Package ${packageName} execution`);
+            const seconds = (executionDuration / 1000).toFixed(1);
+            if (runConfig.debug || runConfig.verbose) {
+                packageLogger.error(`⏱️  Execution time before failure: ${seconds}s`);
+            }
+        }
+        if (runConfig.debug || runConfig.verbose) {
+            packageLogger.error(`❌ Execution failed: ${error.message}`);
+        } else {
+            logger.error(`[${index + 1}/${total}] ${packageName}: ❌ Failed - ${error.message}`);
+        }
+        // Always show stderr if available (contains important error details)
+        // Note: runWithLogging already logs stderr, but we show it here too for visibility
+        // when error is caught at this level (e.g., from timeout wrapper)
+        if (error.stderr && error.stderr.trim() && !runConfig.debug && !runConfig.verbose) {
+            // Extract key error lines from stderr (coverage failures, test failures, etc.)
+            const stderrLines = error.stderr.split('\n').filter((line)=>{
+                const trimmed = line.trim();
+                return trimmed && (trimmed.includes('ERROR:') || trimmed.includes('FAIL') || trimmed.includes('coverage') || trimmed.includes('threshold') || trimmed.includes('fatal:') || trimmed.startsWith('❌'));
+            });
+            if (stderrLines.length > 0) {
+                logger.error(`   Error details:`);
+                stderrLines.slice(0, 10).forEach((line)=>{
+                    logger.error(`   ${line.trim()}`);
+                });
+                if (stderrLines.length > 10) {
+                    logger.error(`   ... and ${stderrLines.length - 10} more error lines (use --verbose to see full output)`);
+                }
+            }
+        }
+        // Check if this is a timeout error
+        const errorMessage = ((_error_message = error.message) === null || _error_message === void 0 ? void 0 : _error_message.toLowerCase()) || '';
+        const isTimeoutError = errorMessage && (errorMessage.includes('timeout waiting for pr') || errorMessage.includes('timeout waiting for release workflows') || errorMessage.includes('timeout reached') || errorMessage.includes('timeout') || errorMessage.includes('timed out') || errorMessage.includes('timed_out'));
+        return {
+            success: false,
+            error,
+            isTimeoutError,
+            logFile: logFilePath
+        };
+    }
+};
+/**
+ * Generate a dry-run preview showing what would happen without executing
+ */ const generateDryRunPreview = async (dependencyGraph, buildOrder, command, runConfig)=>{
+    var _runConfig_tree;
+    const lines = [];
+    lines.push('');
+    lines.push('🔍 DRY RUN MODE - No changes will be made');
+    lines.push('');
+    lines.push('Build order determined:');
+    lines.push('');
+    // Group packages by dependency level
+    const levels = [];
+    const packageLevels = new Map();
+    for (const pkg of buildOrder){
+        const deps = dependencyGraph.edges.get(pkg) || new Set();
+        let maxDepLevel = -1;
+        for (const dep of deps){
+            var _packageLevels_get;
+            const depLevel = (_packageLevels_get = packageLevels.get(dep)) !== null && _packageLevels_get !== void 0 ? _packageLevels_get : 0;
+            maxDepLevel = Math.max(maxDepLevel, depLevel);
+        }
+        const pkgLevel = maxDepLevel + 1;
+        packageLevels.set(pkg, pkgLevel);
+        if (!levels[pkgLevel]) {
+            levels[pkgLevel] = [];
+        }
+        levels[pkgLevel].push(pkg);
+    }
+    // Show packages grouped by level
+    for(let i = 0; i < levels.length; i++){
+        const levelPackages = levels[i];
+        lines.push(`Level ${i + 1}: (${levelPackages.length} package${levelPackages.length === 1 ? '' : 's'})`);
+        for (const pkg of levelPackages){
+            const pkgInfo = dependencyGraph.packages.get(pkg);
+            if (!pkgInfo) continue;
+            // Check if package has changes (for publish command)
+            const isPublish = command.includes('publish');
+            let status = '📝 Has changes, will execute';
+            if (isPublish) {
+                try {
+                    // Check git diff to see if there are code changes
+                    const { stdout } = await runSecure('git', [
+                        'diff',
+                        '--name-only',
+                        'origin/main...HEAD'
+                    ], {
+                        cwd: pkgInfo.path
+                    });
+                    const changedFiles = stdout.split('\n').filter(Boolean);
+                    const nonVersionFiles = changedFiles.filter((f)=>f !== 'package.json' && f !== 'package-lock.json');
+                    if (changedFiles.length === 0) {
+                        status = '⊘ No changes, will skip';
+                    } else if (nonVersionFiles.length === 0) {
+                        status = '⊘ Only version bump, will skip';
+                    } else {
+                        status = `📝 Has changes (${nonVersionFiles.length} files), will publish`;
+                    }
+                } catch  {
+                    // If we can't check git status, assume changes
+                    status = '📝 Will execute';
+                }
+            }
+            lines.push(`  ${pkg}`);
+            lines.push(`    Status: ${status}`);
+            lines.push(`    Path: ${pkgInfo.path}`);
+        }
+        lines.push('');
+    }
+    lines.push('Summary:');
+    lines.push(`  Total packages: ${buildOrder.length}`);
+    lines.push(`  Dependency levels: ${levels.length}`);
+    lines.push(`  Command: ${command}`);
+    if ((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.maxConcurrency) {
+        lines.push(`  Max concurrency: ${runConfig.tree.maxConcurrency}`);
+    }
+    lines.push('');
+    lines.push('To execute for real, run the same command without --dry-run');
+    lines.push('');
+    return lines.join('\n');
+};
+// Add a simple status check function
+const checkTreePublishStatus = async ()=>{
+    const logger = getLogger();
+    try {
+        // Check for running kodrdriv processes
+        const { stdout } = await runSecure('ps', [
+            'aux'
+        ], {});
+        const kodrdrivProcesses = stdout.split('\n').filter((line)=>line.includes('kodrdriv') && !line.includes('grep') && !line.includes('ps aux') && !line.includes('tree --status') // Exclude the current status command
+        );
+        if (kodrdrivProcesses.length > 0) {
+            logger.info('🔍 Found running kodrdriv processes:');
+            kodrdrivProcesses.forEach((process1)=>{
+                const parts = process1.trim().split(/\s+/);
+                const pid = parts[1];
+                const command = parts.slice(10).join(' ');
+                logger.info(`  PID ${pid}: ${command}`);
+            });
+        } else {
+            logger.info('No kodrdriv processes currently running');
+        }
+    } catch (error) {
+        logger.warn('Could not check process status:', error);
+    }
+};
+const execute$1 = async (runConfig)=>{
+    var _runConfig_tree, _runConfig_tree1, _runConfig_tree2, _runConfig_tree3, _runConfig_tree4, _runConfig_tree5, _runConfig_tree6, _runConfig_tree7, _runConfig_tree8, _runConfig_tree9, _runConfig_tree10, _runConfig_tree11, _runConfig_tree12, _runConfig_tree13, _runConfig_tree14, _runConfig_tree15;
+    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;
+    const promotePackage = (_runConfig_tree1 = runConfig.tree) === null || _runConfig_tree1 === void 0 ? void 0 : _runConfig_tree1.promote;
+    // Debug logging
+    logger.debug('Tree config:', JSON.stringify(runConfig.tree, null, 2));
+    logger.debug('Status flag:', (_runConfig_tree2 = runConfig.tree) === null || _runConfig_tree2 === void 0 ? void 0 : _runConfig_tree2.status);
+    logger.debug('Full runConfig:', JSON.stringify(runConfig, null, 2));
+    // Handle status check
+    if ((_runConfig_tree3 = runConfig.tree) === null || _runConfig_tree3 === void 0 ? void 0 : _runConfig_tree3.status) {
+        logger.info('🔍 Checking for running kodrdriv processes...');
+        await checkTreePublishStatus();
+        return 'Status check completed';
+    }
+    // Handle promote mode
+    if (promotePackage) {
+        logger.info(`Promoting package '${promotePackage}' to completed status...`);
+        await promotePackageToCompleted(promotePackage, runConfig.outputDirectory);
+        logger.info(`✅ Package '${promotePackage}' has been marked as completed.`);
+        logger.info('You can now run the tree command with --continue to resume from the next package.');
+        return `Package '${promotePackage}' promoted to completed status.`;
+    }
+    // Handle audit-branches command
+    if ((_runConfig_tree4 = runConfig.tree) === null || _runConfig_tree4 === void 0 ? void 0 : _runConfig_tree4.auditBranches) {
+        var _runConfig_tree16, _runConfig_tree17, _runConfig_publish, _runConfig_tree18;
+        logger.info('🔍 Auditing branch state across all packages...');
+        const directories = ((_runConfig_tree16 = runConfig.tree) === null || _runConfig_tree16 === void 0 ? void 0 : _runConfig_tree16.directories) || [
+            process.cwd()
+        ];
+        const excludedPatterns = ((_runConfig_tree17 = runConfig.tree) === null || _runConfig_tree17 === void 0 ? void 0 : _runConfig_tree17.exclude) || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        if (allPackageJsonPaths.length === 0) {
+            return 'No packages found';
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const packages = Array.from(dependencyGraph.packages.values()).map((pkg)=>({
+                name: pkg.name,
+                path: pkg.path
+            }));
+        const { auditBranchState, formatAuditResults } = await import('./branchState-CtywDSJf.js');
+        const { getRemoteDefaultBranch } = await import('@eldrforge/git-tools');
+        // For publish workflows, check branch consistency, merge conflicts, and existing PRs
+        // Don't pass an expected branch - let the audit find the most common branch
+        let targetBranch = (_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch;
+        if (!targetBranch) {
+            // Try to detect default branch from the first package that is a git repo
+            const firstGitPkg = packages.find((pkg)=>isInGitRepository(pkg.path));
+            if (firstGitPkg) {
+                try {
+                    // Cast to any to avoid type mismatch with node_modules version
+                    targetBranch = await getRemoteDefaultBranch(firstGitPkg.path) || 'main';
+                } catch  {
+                    targetBranch = 'main';
+                }
+            } else {
+                targetBranch = 'main';
+            }
+        }
+        logger.info(`Checking for merge conflicts with '${targetBranch}' and existing pull requests...`);
+        const auditResult = await auditBranchState(packages, undefined, {
+            targetBranch,
+            checkPR: true,
+            checkConflicts: true,
+            concurrency: ((_runConfig_tree18 = runConfig.tree) === null || _runConfig_tree18 === void 0 ? void 0 : _runConfig_tree18.maxConcurrency) || 10
+        });
+        const formatted = formatAuditResults(auditResult);
+        logger.info('\n' + formatted);
+        if (auditResult.issuesFound > 0) {
+            logger.warn(`\n⚠️  Found issues in ${auditResult.issuesFound} package(s). Review the fixes above.`);
+            return `Branch audit complete: ${auditResult.issuesFound} package(s) need attention`;
+        }
+        logger.info(`\n✅ All ${auditResult.goodPackages} package(s) are in good state!`);
+        return `Branch audit complete: All packages OK`;
+    }
+    // Handle parallel execution recovery commands
+    const { loadRecoveryManager } = await import('@eldrforge/tree-execution');
+    // Handle status-parallel command
+    if ((_runConfig_tree5 = runConfig.tree) === null || _runConfig_tree5 === void 0 ? void 0 : _runConfig_tree5.statusParallel) {
+        var _runConfig_tree19, _runConfig_tree20;
+        logger.info('📊 Checking parallel execution status...');
+        // Need to build dependency graph first
+        const directories = ((_runConfig_tree19 = runConfig.tree) === null || _runConfig_tree19 === void 0 ? void 0 : _runConfig_tree19.directories) || [
+            process.cwd()
+        ];
+        const excludedPatterns = ((_runConfig_tree20 = runConfig.tree) === null || _runConfig_tree20 === void 0 ? void 0 : _runConfig_tree20.exclude) || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        if (allPackageJsonPaths.length === 0) {
+            return 'No packages found';
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.info('No parallel execution checkpoint found');
+            return 'No active parallel execution found';
+        }
+        const status = await recoveryManager.showStatus();
+        logger.info('\n' + status);
+        return status;
+    }
+    // Handle validate-state command
+    if ((_runConfig_tree6 = runConfig.tree) === null || _runConfig_tree6 === void 0 ? void 0 : _runConfig_tree6.validateState) {
+        var _runConfig_tree21, _runConfig_tree22;
+        logger.info('🔍 Validating checkpoint state...');
+        const directories = ((_runConfig_tree21 = runConfig.tree) === null || _runConfig_tree21 === void 0 ? void 0 : _runConfig_tree21.directories) || [
+            process.cwd()
+        ];
+        const excludedPatterns = ((_runConfig_tree22 = runConfig.tree) === null || _runConfig_tree22 === void 0 ? void 0 : _runConfig_tree22.exclude) || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        if (allPackageJsonPaths.length === 0) {
+            return 'No packages found';
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.info('No checkpoint found to validate');
+            return 'No checkpoint found';
+        }
+        const validation = recoveryManager.validateState();
+        if (validation.valid) {
+            logger.info('✅ Checkpoint state is valid');
+        } else {
+            logger.error('❌ Checkpoint state has issues:');
+            for (const issue of validation.issues){
+                logger.error(`  • ${issue}`);
+            }
+        }
+        if (validation.warnings.length > 0) {
+            logger.warn('⚠️  Warnings:');
+            for (const warning of validation.warnings){
+                logger.warn(`  • ${warning}`);
+            }
+        }
+        return validation.valid ? 'Checkpoint is valid' : 'Checkpoint has issues';
+    }
+    // Handle parallel execution recovery options (must happen before main execution)
+    const hasRecoveryOptions = ((_runConfig_tree7 = runConfig.tree) === null || _runConfig_tree7 === void 0 ? void 0 : _runConfig_tree7.markCompleted) || ((_runConfig_tree8 = runConfig.tree) === null || _runConfig_tree8 === void 0 ? void 0 : _runConfig_tree8.skipPackages) || ((_runConfig_tree9 = runConfig.tree) === null || _runConfig_tree9 === void 0 ? void 0 : _runConfig_tree9.retryFailed) || ((_runConfig_tree10 = runConfig.tree) === null || _runConfig_tree10 === void 0 ? void 0 : _runConfig_tree10.skipFailed) || ((_runConfig_tree11 = runConfig.tree) === null || _runConfig_tree11 === void 0 ? void 0 : _runConfig_tree11.resetPackage);
+    if (hasRecoveryOptions && runConfig.tree) {
+        var _runConfig_tree_retry;
+        logger.info('🔧 Applying recovery options...');
+        // Build dependency graph
+        const directories = runConfig.tree.directories || [
+            process.cwd()
+        ];
+        const excludedPatterns = runConfig.tree.exclude || [];
+        let allPackageJsonPaths = [];
+        for (const targetDirectory of directories){
+            const packageJsonPaths = await scanForPackageJsonFiles(targetDirectory, excludedPatterns);
+            allPackageJsonPaths = allPackageJsonPaths.concat(packageJsonPaths);
+        }
+        const dependencyGraph = await buildDependencyGraph(allPackageJsonPaths);
+        const recoveryManager = await loadRecoveryManager(dependencyGraph, runConfig.outputDirectory);
+        if (!recoveryManager) {
+            logger.error('No checkpoint found for recovery');
+            throw new Error('No checkpoint found. Cannot apply recovery options without an existing checkpoint.');
+        }
+        await recoveryManager.applyRecoveryOptions({
+            markCompleted: runConfig.tree.markCompleted,
+            skipPackages: runConfig.tree.skipPackages,
+            retryFailed: runConfig.tree.retryFailed,
+            skipFailed: runConfig.tree.skipFailed,
+            resetPackage: runConfig.tree.resetPackage,
+            maxRetries: (_runConfig_tree_retry = runConfig.tree.retry) === null || _runConfig_tree_retry === void 0 ? void 0 : _runConfig_tree_retry.maxAttempts
+        });
+        logger.info('✅ Recovery options applied');
+        // If not also continuing, just return
+        if (!isContinue) {
+            return 'Recovery options applied. Use --continue to resume execution.';
+        }
+    }
+    // Handle continue mode
+    if (isContinue) {
+        var _runConfig_tree23;
+        // For parallel execution, the checkpoint is managed by DynamicTaskPool/CheckpointManager
+        // For sequential execution, we use the legacy context file
+        const isParallelMode = (_runConfig_tree23 = runConfig.tree) === null || _runConfig_tree23 === void 0 ? void 0 : _runConfig_tree23.parallel;
+        if (!isParallelMode) {
+            // Sequential execution: load legacy context
+            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 {
+            // Parallel execution: checkpoint is managed by DynamicTaskPool
+            // Just log that we're continuing - the actual checkpoint loading happens in DynamicTaskPool
+            logger.info('Continuing previous parallel 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_tree12 = runConfig.tree) === null || _runConfig_tree12 === void 0 ? void 0 : _runConfig_tree12.builtInCommand;
+    const supportedBuiltInCommands = [
+        'commit',
+        'release',
+        'publish',
+        'link',
+        'unlink',
+        'development',
+        'branches',
+        'run',
+        'checkout',
+        'updates',
+        'precommit'
+    ];
+    if (builtInCommand && !supportedBuiltInCommands.includes(builtInCommand)) {
+        throw new Error(`Unsupported built-in command: ${builtInCommand}. Supported commands: ${supportedBuiltInCommands.join(', ')}`);
+    }
+    // Handle run subcommand - convert space-separated scripts to npm run commands
+    if (builtInCommand === 'run') {
+        var _runConfig_tree24;
+        const packageArgument = (_runConfig_tree24 = runConfig.tree) === null || _runConfig_tree24 === void 0 ? void 0 : _runConfig_tree24.packageArgument;
+        if (!packageArgument) {
+            throw new Error('run subcommand requires script names. Usage: kodrdriv tree run "clean build test"');
+        }
+        // Split the package argument by spaces to get individual script names
+        const scripts = packageArgument.trim().split(/\s+/).filter((script)=>script.length > 0);
+        if (scripts.length === 0) {
+            throw new Error('run subcommand requires at least one script name. Usage: kodrdriv tree run "clean build test"');
+        }
+        // Convert to npm run commands joined with &&
+        const npmCommands = scripts.map((script)=>`npm run ${script}`).join(' && ');
+        // Set this as the custom command to run
+        runConfig.tree = {
+            ...runConfig.tree,
+            cmd: npmCommands
+        };
+        // Clear the built-in command since we're now using custom command mode
+        runConfig.tree.builtInCommand = undefined;
+        logger.info(`Converting run subcommand to: ${npmCommands}`);
+        // Store scripts for later validation
+        runConfig.__scriptsToValidate = scripts;
+    }
+    // Determine the target directories - either specified or current working directory
+    const directories = ((_runConfig_tree13 = runConfig.tree) === null || _runConfig_tree13 === void 0 ? void 0 : _runConfig_tree13.directories) || [
+        process.cwd()
+    ];
+    // Handle link status subcommand
+    if (builtInCommand === 'link' && ((_runConfig_tree14 = runConfig.tree) === null || _runConfig_tree14 === void 0 ? void 0 : _runConfig_tree14.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$4(linkConfig, 'status');
+            return result;
+        } catch (error) {
+            logger.error(`Link status failed: ${error.message}`);
+            throw error;
+        }
+    }
+    // Handle unlink status subcommand
+    if (builtInCommand === 'unlink' && ((_runConfig_tree15 = runConfig.tree) === null || _runConfig_tree15 === void 0 ? void 0 : _runConfig_tree15.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$3(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: ${directories.join(', ')}`);
+    }
+    try {
+        var _runConfig_tree25, _runConfig_tree26, _runConfig_tree27, _runConfig_tree28;
+        // Get exclusion patterns from config, fallback to empty array
+        const excludedPatterns = ((_runConfig_tree25 = runConfig.tree) === null || _runConfig_tree25 === void 0 ? void 0 : _runConfig_tree25.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 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 = directories.join(', ');
+            const message = `No package.json files found in subdirectories of: ${directoriesStr}`;
+            logger.warn(message);
+            return message;
+        }
+        logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Found ${packageJsonPaths.length} package.json files`);
+        // Build dependency graph
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Building dependency graph...`);
+        const dependencyGraph = await buildDependencyGraph(packageJsonPaths);
+        // Perform topological sort to determine build order
+        logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Determining build order...`);
+        let buildOrder = topologicalSort(dependencyGraph);
+        // Handle start-from functionality if specified
+        const startFrom = (_runConfig_tree26 = runConfig.tree) === null || _runConfig_tree26 === void 0 ? void 0 : _runConfig_tree26.startFrom;
+        if (startFrom) {
+            logger.verbose(`${isDryRun ? 'DRY RUN: ' : ''}Looking for start package: ${startFrom}`);
+            // Resolve the actual package name (can be package name or directory name)
+            let startPackageName = null;
+            for (const [pkgName, pkgInfo] of dependencyGraph.packages){
+                const dirName = path.basename(pkgInfo.path);
+                if (dirName === startFrom || pkgName === startFrom) {
+                    startPackageName = pkgName;
+                    break;
+                }
+            }
+            if (!startPackageName) {
+                // Check if the package exists but was excluded across all directories
+                let allPackageJsonPathsForCheck = [];
+                for (const targetDirectory of directories){
+                    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.basename(packageInfo.path);
+                        if (dirName === startFrom || packageInfo.name === startFrom) {
+                            // 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 '${startFrom}' was excluded by exclusion patterns: ${excludedPatternsStr}. Remove the exclusion pattern or choose a different starting package.`);
+                } else {
+                    const availablePackages = buildOrder.map((name)=>{
+                        const packageInfo = dependencyGraph.packages.get(name);
+                        return `${path.basename(packageInfo.path)} (${name})`;
+                    }).join(', ');
+                    throw new Error(`Package directory '${startFrom}' not found. Available packages: ${availablePackages}`);
+                }
+            }
+            // Find the start package in the build order and start execution from there
+            const startIndex = buildOrder.findIndex((pkgName)=>pkgName === startPackageName);
+            if (startIndex === -1) {
+                throw new Error(`Package '${startFrom}' not found in build order. This should not happen.`);
+            }
+            // Filter build order to start from the specified package
+            const originalLength = buildOrder.length;
+            buildOrder = buildOrder.slice(startIndex);
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Starting execution from package '${startFrom}' (${buildOrder.length} of ${originalLength} packages remaining).`);
+        }
+        // Handle stop-at functionality if specified
+        const stopAt = (_runConfig_tree27 = runConfig.tree) === null || _runConfig_tree27 === void 0 ? void 0 : _runConfig_tree27.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.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 directories){
+                    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.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.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.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 = createStorage();
+            // 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.`;
+        }
+        // Handle special "checkout" command that switches all packages to specified branch
+        if (builtInCommand === 'checkout') {
+            var _runConfig_tree29;
+            const targetBranch = (_runConfig_tree29 = runConfig.tree) === null || _runConfig_tree29 === void 0 ? void 0 : _runConfig_tree29.packageArgument;
+            if (!targetBranch) {
+                throw new Error('checkout subcommand requires a branch name. Usage: kodrdriv tree checkout <branch-name>');
+            }
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Workspace Checkout to Branch: ${targetBranch}`);
+            logger.info('');
+            // Phase 1: Safety check - scan all packages for uncommitted changes
+            logger.info('🔍 Phase 1: Checking for uncommitted changes across workspace...');
+            const packagesWithChanges = [];
+            for (const packageName of buildOrder){
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                try {
+                    const gitStatus = await getGitStatusSummary(packageInfo.path);
+                    const hasProblems = gitStatus.hasUncommittedChanges || gitStatus.hasUnstagedFiles;
+                    packagesWithChanges.push({
+                        name: packageName,
+                        path: packageInfo.path,
+                        status: gitStatus.status,
+                        hasUncommittedChanges: gitStatus.hasUncommittedChanges,
+                        hasUnstagedFiles: gitStatus.hasUnstagedFiles
+                    });
+                    if (hasProblems) {
+                        logger.warn(`⚠️  ${packageName}: ${gitStatus.status}`);
+                    } else {
+                        logger.verbose(`✅ ${packageName}: clean`);
+                    }
+                } catch (error) {
+                    logger.warn(`❌ ${packageName}: error checking status - ${error.message}`);
+                    packagesWithChanges.push({
+                        name: packageName,
+                        path: packageInfo.path,
+                        status: 'error',
+                        hasUncommittedChanges: false,
+                        hasUnstagedFiles: false
+                    });
+                }
+            }
+            // Check if any packages have uncommitted changes
+            const problemPackages = packagesWithChanges.filter((pkg)=>pkg.hasUncommittedChanges || pkg.hasUnstagedFiles || pkg.status === 'error');
+            if (problemPackages.length > 0) {
+                logger.error(`❌ Cannot proceed with checkout: ${problemPackages.length} packages have uncommitted changes or errors:`);
+                logger.error('');
+                for (const pkg of problemPackages){
+                    logger.error(`  📦 ${pkg.name} (${pkg.path}):`);
+                    logger.error(`      Status: ${pkg.status}`);
+                }
+                logger.error('');
+                logger.error('🔧 To resolve this issue:');
+                logger.error('   1. Commit or stash changes in the packages listed above');
+                logger.error('   2. Or use "kodrdriv tree commit" to commit changes across all packages');
+                logger.error('   3. Then re-run the checkout command');
+                logger.error('');
+                throw new Error(`Workspace checkout blocked: ${problemPackages.length} packages have uncommitted changes`);
+            }
+            logger.info(`✅ Phase 1 complete: All ${packagesWithChanges.length} packages are clean`);
+            logger.info('');
+            // Phase 2: Perform the checkout
+            logger.info(`🔄 Phase 2: Checking out all packages to branch '${targetBranch}'...`);
+            let successCount = 0;
+            const failedPackages = [];
+            for(let i = 0; i < buildOrder.length; i++){
+                const packageName = buildOrder[i];
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                if (isDryRun) {
+                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: Would checkout ${targetBranch}`);
+                    successCount++;
+                } else {
+                    try {
+                        const originalCwd = process.cwd();
+                        process.chdir(packageInfo.path);
+                        try {
+                            // Check if target branch exists locally
+                            let branchExists = false;
+                            try {
+                                await runSecure('git', [
+                                    'rev-parse',
+                                    '--verify',
+                                    targetBranch
+                                ]);
+                                branchExists = true;
+                            } catch  {
+                                // Branch doesn't exist locally
+                                branchExists = false;
+                            }
+                            if (branchExists) {
+                                await runSecure('git', [
+                                    'checkout',
+                                    targetBranch
+                                ]);
+                                logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Checked out ${targetBranch}`);
+                            } else {
+                                // Try to check out branch from remote
+                                try {
+                                    await runSecure('git', [
+                                        'checkout',
+                                        '-b',
+                                        targetBranch,
+                                        `origin/${targetBranch}`
+                                    ]);
+                                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Checked out ${targetBranch} from origin`);
+                                } catch  {
+                                    // If that fails, create a new branch
+                                    await runSecure('git', [
+                                        'checkout',
+                                        '-b',
+                                        targetBranch
+                                    ]);
+                                    logger.info(`[${i + 1}/${buildOrder.length}] ${packageName}: ✅ Created new branch ${targetBranch}`);
+                                }
+                            }
+                            successCount++;
+                        } finally{
+                            process.chdir(originalCwd);
+                        }
+                    } catch (error) {
+                        logger.error(`[${i + 1}/${buildOrder.length}] ${packageName}: ❌ Failed - ${error.message}`);
+                        failedPackages.push({
+                            name: packageName,
+                            error: error.message
+                        });
+                    }
+                }
+            }
+            // Report results
+            if (failedPackages.length > 0) {
+                logger.error(`❌ Checkout completed with errors: ${successCount}/${buildOrder.length} packages successful`);
+                logger.error('');
+                logger.error('Failed packages:');
+                for (const failed of failedPackages){
+                    logger.error(`  - ${failed.name}: ${failed.error}`);
+                }
+                throw new Error(`Checkout failed for ${failedPackages.length} packages`);
+            } else {
+                logger.info(`✅ Checkout complete: All ${buildOrder.length} packages successfully checked out to '${targetBranch}'`);
+                return `Workspace checkout complete: ${successCount} packages checked out to '${targetBranch}'`;
+            }
+        }
+        // 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
+            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);
+                const localDeps = Array.from(packageInfo.localDependencies);
+                logger.info(`${index + 1}. ${packageName} (${packageInfo.version})`);
+                logger.info(`   Path: ${packageInfo.path}`);
+                if (localDeps.length > 0) {
+                    logger.info(`   Local Dependencies: ${localDeps.join(', ')}`);
+                } else {
+                    logger.info(`   Local Dependencies: none`);
+                }
+                logger.info(''); // Add spacing between packages
+            });
+            // Simple return output for verbose mode (no need to repeat detailed info)
+            returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
+        } else {
+            // Non-verbose mode: Show simple build order
+            buildOrder.forEach((packageName, index)=>{
+                const packageInfo = dependencyGraph.packages.get(packageName);
+                const localDeps = Array.from(packageInfo.localDependencies);
+                // Log each step
+                if (localDeps.length > 0) {
+                    logger.info(`${index + 1}. ${packageName} (depends on: ${localDeps.join(', ')})`);
+                } else {
+                    logger.info(`${index + 1}. ${packageName} (no local dependencies)`);
+                }
+            });
+            // Simple return output for non-verbose mode
+            returnOutput = `\nBuild order: ${buildOrder.join(' → ')}\n`;
+        }
+        // Execute command if provided (custom command or built-in command)
+        const cmd = (_runConfig_tree28 = runConfig.tree) === null || _runConfig_tree28 === void 0 ? void 0 : _runConfig_tree28.cmd;
+        // Determine command to execute
+        let commandToRun;
+        let isBuiltInCommand = false;
+        if (builtInCommand) {
+            var _runConfig_tree30, _runConfig_tree31, _runConfig_tree32;
+            // Built-in command mode: shell out to kodrdriv subprocess
+            // 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/updates commands
+            const packageArg = (_runConfig_tree30 = runConfig.tree) === null || _runConfig_tree30 === void 0 ? void 0 : _runConfig_tree30.packageArgument;
+            const packageArgString = packageArg && (builtInCommand === 'link' || builtInCommand === 'unlink' || builtInCommand === 'updates') ? ` "${packageArg}"` : '';
+            // Add command-specific options
+            let commandSpecificOptions = '';
+            // Commit command options
+            if (builtInCommand === 'commit') {
+                var _runConfig_commit, _runConfig_commit1, _runConfig_commit2, _runConfig_commit3, _runConfig_commit4, _runConfig_commit5, _runConfig_commit6, _runConfig_commit7, _runConfig_commit8, _runConfig_commit9, _runConfig_commit10, _runConfig_commit11, _runConfig_commit12, _runConfig_commit13, _runConfig_commit14, _runConfig_commit15, _runConfig_commit16;
+                if ((_runConfig_commit = runConfig.commit) === null || _runConfig_commit === void 0 ? void 0 : _runConfig_commit.selfReflection) {
+                    commandSpecificOptions += ' --self-reflection';
+                }
+                if ((_runConfig_commit1 = runConfig.commit) === null || _runConfig_commit1 === void 0 ? void 0 : _runConfig_commit1.add) {
+                    commandSpecificOptions += ' --add';
+                }
+                if ((_runConfig_commit2 = runConfig.commit) === null || _runConfig_commit2 === void 0 ? void 0 : _runConfig_commit2.cached) {
+                    commandSpecificOptions += ' --cached';
+                }
+                if ((_runConfig_commit3 = runConfig.commit) === null || _runConfig_commit3 === void 0 ? void 0 : _runConfig_commit3.interactive) {
+                    commandSpecificOptions += ' --interactive';
+                }
+                if ((_runConfig_commit4 = runConfig.commit) === null || _runConfig_commit4 === void 0 ? void 0 : _runConfig_commit4.amend) {
+                    commandSpecificOptions += ' --amend';
+                }
+                if ((_runConfig_commit5 = runConfig.commit) === null || _runConfig_commit5 === void 0 ? void 0 : _runConfig_commit5.skipFileCheck) {
+                    commandSpecificOptions += ' --skip-file-check';
+                }
+                if ((_runConfig_commit6 = runConfig.commit) === null || _runConfig_commit6 === void 0 ? void 0 : _runConfig_commit6.maxAgenticIterations) {
+                    commandSpecificOptions += ` --max-agentic-iterations ${runConfig.commit.maxAgenticIterations}`;
+                }
+                if ((_runConfig_commit7 = runConfig.commit) === null || _runConfig_commit7 === void 0 ? void 0 : _runConfig_commit7.allowCommitSplitting) {
+                    commandSpecificOptions += ' --allow-commit-splitting';
+                }
+                if ((_runConfig_commit8 = runConfig.commit) === null || _runConfig_commit8 === void 0 ? void 0 : _runConfig_commit8.messageLimit) {
+                    commandSpecificOptions += ` --message-limit ${runConfig.commit.messageLimit}`;
+                }
+                if ((_runConfig_commit9 = runConfig.commit) === null || _runConfig_commit9 === void 0 ? void 0 : _runConfig_commit9.maxDiffBytes) {
+                    commandSpecificOptions += ` --max-diff-bytes ${runConfig.commit.maxDiffBytes}`;
+                }
+                if ((_runConfig_commit10 = runConfig.commit) === null || _runConfig_commit10 === void 0 ? void 0 : _runConfig_commit10.direction) {
+                    commandSpecificOptions += ` --direction "${runConfig.commit.direction}"`;
+                }
+                if ((_runConfig_commit11 = runConfig.commit) === null || _runConfig_commit11 === void 0 ? void 0 : _runConfig_commit11.context) {
+                    commandSpecificOptions += ` --context "${runConfig.commit.context}"`;
+                }
+                if (((_runConfig_commit12 = runConfig.commit) === null || _runConfig_commit12 === void 0 ? void 0 : _runConfig_commit12.contextFiles) && runConfig.commit.contextFiles.length > 0) {
+                    commandSpecificOptions += ` --context-files ${runConfig.commit.contextFiles.join(' ')}`;
+                }
+                // Push option can be boolean or string (remote name)
+                if ((_runConfig_commit13 = runConfig.commit) === null || _runConfig_commit13 === void 0 ? void 0 : _runConfig_commit13.push) {
+                    if (typeof runConfig.commit.push === 'string') {
+                        commandSpecificOptions += ` --push "${runConfig.commit.push}"`;
+                    } else {
+                        commandSpecificOptions += ' --push';
+                    }
+                }
+                // Model-specific options for commit
+                if ((_runConfig_commit14 = runConfig.commit) === null || _runConfig_commit14 === void 0 ? void 0 : _runConfig_commit14.model) {
+                    commandSpecificOptions += ` --model "${runConfig.commit.model}"`;
+                }
+                if ((_runConfig_commit15 = runConfig.commit) === null || _runConfig_commit15 === void 0 ? void 0 : _runConfig_commit15.openaiReasoning) {
+                    commandSpecificOptions += ` --openai-reasoning ${runConfig.commit.openaiReasoning}`;
+                }
+                if ((_runConfig_commit16 = runConfig.commit) === null || _runConfig_commit16 === void 0 ? void 0 : _runConfig_commit16.openaiMaxOutputTokens) {
+                    commandSpecificOptions += ` --openai-max-output-tokens ${runConfig.commit.openaiMaxOutputTokens}`;
+                }
+            }
+            // Release command options (only for direct 'release' command)
+            if (builtInCommand === 'release') {
+                var _runConfig_release, _runConfig_release1, _runConfig_release2, _runConfig_release3, _runConfig_release4, _runConfig_release5, _runConfig_release6, _runConfig_release7, _runConfig_release8, _runConfig_release9, _runConfig_release10, _runConfig_release11, _runConfig_release12, _runConfig_release13, _runConfig_release14;
+                if ((_runConfig_release = runConfig.release) === null || _runConfig_release === void 0 ? void 0 : _runConfig_release.selfReflection) {
+                    commandSpecificOptions += ' --self-reflection';
+                }
+                if ((_runConfig_release1 = runConfig.release) === null || _runConfig_release1 === void 0 ? void 0 : _runConfig_release1.maxAgenticIterations) {
+                    commandSpecificOptions += ` --max-agentic-iterations ${runConfig.release.maxAgenticIterations}`;
+                }
+                if ((_runConfig_release2 = runConfig.release) === null || _runConfig_release2 === void 0 ? void 0 : _runConfig_release2.interactive) {
+                    commandSpecificOptions += ' --interactive';
+                }
+                if ((_runConfig_release3 = runConfig.release) === null || _runConfig_release3 === void 0 ? void 0 : _runConfig_release3.from) {
+                    commandSpecificOptions += ` --from "${runConfig.release.from}"`;
+                }
+                if ((_runConfig_release4 = runConfig.release) === null || _runConfig_release4 === void 0 ? void 0 : _runConfig_release4.to) {
+                    commandSpecificOptions += ` --to "${runConfig.release.to}"`;
+                }
+                if ((_runConfig_release5 = runConfig.release) === null || _runConfig_release5 === void 0 ? void 0 : _runConfig_release5.focus) {
+                    commandSpecificOptions += ` --focus "${runConfig.release.focus}"`;
+                }
+                if ((_runConfig_release6 = runConfig.release) === null || _runConfig_release6 === void 0 ? void 0 : _runConfig_release6.context) {
+                    commandSpecificOptions += ` --context "${runConfig.release.context}"`;
+                }
+                if (((_runConfig_release7 = runConfig.release) === null || _runConfig_release7 === void 0 ? void 0 : _runConfig_release7.contextFiles) && runConfig.release.contextFiles.length > 0) {
+                    commandSpecificOptions += ` --context-files ${runConfig.release.contextFiles.join(' ')}`;
+                }
+                if ((_runConfig_release8 = runConfig.release) === null || _runConfig_release8 === void 0 ? void 0 : _runConfig_release8.messageLimit) {
+                    commandSpecificOptions += ` --message-limit ${runConfig.release.messageLimit}`;
+                }
+                if ((_runConfig_release9 = runConfig.release) === null || _runConfig_release9 === void 0 ? void 0 : _runConfig_release9.maxDiffBytes) {
+                    commandSpecificOptions += ` --max-diff-bytes ${runConfig.release.maxDiffBytes}`;
+                }
+                if ((_runConfig_release10 = runConfig.release) === null || _runConfig_release10 === void 0 ? void 0 : _runConfig_release10.noMilestones) {
+                    commandSpecificOptions += ' --no-milestones';
+                }
+                if ((_runConfig_release11 = runConfig.release) === null || _runConfig_release11 === void 0 ? void 0 : _runConfig_release11.fromMain) {
+                    commandSpecificOptions += ' --from-main';
+                }
+                // Model-specific options for release
+                if ((_runConfig_release12 = runConfig.release) === null || _runConfig_release12 === void 0 ? void 0 : _runConfig_release12.model) {
+                    commandSpecificOptions += ` --model "${runConfig.release.model}"`;
+                }
+                if ((_runConfig_release13 = runConfig.release) === null || _runConfig_release13 === void 0 ? void 0 : _runConfig_release13.openaiReasoning) {
+                    commandSpecificOptions += ` --openai-reasoning ${runConfig.release.openaiReasoning}`;
+                }
+                if ((_runConfig_release14 = runConfig.release) === null || _runConfig_release14 === void 0 ? void 0 : _runConfig_release14.openaiMaxOutputTokens) {
+                    commandSpecificOptions += ` --openai-max-output-tokens ${runConfig.release.openaiMaxOutputTokens}`;
+                }
+            }
+            // Publish command options (pass self-reflection - publish reads other release config from config file)
+            if (builtInCommand === 'publish') {
+                var _runConfig_release15, _runConfig_release16;
+                if ((_runConfig_release15 = runConfig.release) === null || _runConfig_release15 === void 0 ? void 0 : _runConfig_release15.selfReflection) {
+                    commandSpecificOptions += ' --self-reflection';
+                }
+                if ((_runConfig_release16 = runConfig.release) === null || _runConfig_release16 === void 0 ? void 0 : _runConfig_release16.maxAgenticIterations) {
+                    commandSpecificOptions += ` --max-agentic-iterations ${runConfig.release.maxAgenticIterations}`;
+                }
+            // Publish has its own --from, --interactive, --from-main flags (not from release config)
+            }
+            // Unlink command options
+            if (builtInCommand === 'unlink' && ((_runConfig_tree31 = runConfig.tree) === null || _runConfig_tree31 === void 0 ? void 0 : _runConfig_tree31.cleanNodeModules)) {
+                commandSpecificOptions += ' --clean-node-modules';
+            }
+            // Link/Unlink externals
+            if ((builtInCommand === 'link' || builtInCommand === 'unlink') && ((_runConfig_tree32 = runConfig.tree) === null || _runConfig_tree32 === void 0 ? void 0 : _runConfig_tree32.externals) && runConfig.tree.externals.length > 0) {
+                commandSpecificOptions += ` --externals ${runConfig.tree.externals.join(' ')}`;
+            }
+            commandToRun = `kodrdriv ${builtInCommand}${optionsString}${packageArgString}${commandSpecificOptions}`;
+            isBuiltInCommand = true;
+        } else if (cmd) {
+            // Custom command mode
+            commandToRun = cmd;
+        }
+        if (commandToRun) {
+            var _runConfig_tree33, _runConfig_tree34;
+            // Validate scripts for run command before execution
+            const scriptsToValidate = runConfig.__scriptsToValidate;
+            if (scriptsToValidate && scriptsToValidate.length > 0) {
+                logger.info(`🔍 Validating scripts before execution: ${scriptsToValidate.join(', ')}`);
+                const validation = await validateScripts(dependencyGraph.packages, scriptsToValidate);
+                if (!validation.valid) {
+                    logger.error('');
+                    logger.error('❌ Script validation failed. Cannot proceed with execution.');
+                    logger.error('');
+                    logger.error('💡 To fix this:');
+                    logger.error('   1. Add the missing scripts to the package.json files');
+                    logger.error('   2. Or exclude packages that don\'t need these scripts using --exclude');
+                    logger.error('   3. Or run individual packages that have the required scripts');
+                    logger.error('');
+                    throw new Error('Script validation failed. See details above.');
+                }
+            }
+            // Validate command for parallel execution if parallel mode is enabled
+            if ((_runConfig_tree33 = runConfig.tree) === null || _runConfig_tree33 === void 0 ? void 0 : _runConfig_tree33.parallel) {
+                const { CommandValidator } = await import('@eldrforge/tree-execution');
+                const validation = CommandValidator.validateForParallel(commandToRun, builtInCommand);
+                CommandValidator.logValidation(validation);
+                if (!validation.valid) {
+                    logger.error('');
+                    logger.error('Cannot proceed with parallel execution due to validation errors.');
+                    logger.error('Run without --parallel flag to execute sequentially.');
+                    throw new Error('Command validation failed for parallel execution');
+                }
+                // Apply recommended concurrency if not explicitly set
+                if (!runConfig.tree.maxConcurrency) {
+                    const os = await import('os');
+                    const recommended = CommandValidator.getRecommendedConcurrency(builtInCommand, os.cpus().length, commandToRun);
+                    if (recommended !== os.cpus().length) {
+                        const reason = builtInCommand ? builtInCommand : `custom command "${commandToRun}"`;
+                        logger.info(`💡 Using recommended concurrency for ${reason}: ${recommended}`);
+                        runConfig.tree.maxConcurrency = recommended;
+                    }
+                }
+            }
+            // 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 for commands that support continuation
+                if (isBuiltInCommand && (builtInCommand === 'publish' || builtInCommand === 'run') && !isDryRun) {
+                    await saveExecutionContext(executionContext, runConfig.outputDirectory);
+                }
+            }
+            // Add spacing before command execution
+            logger.info('');
+            const executionDescription = isBuiltInCommand ? `built-in command "${builtInCommand}"` : `"${commandToRun}"`;
+            logger.info(`${isDryRun ? 'DRY RUN: ' : ''}Executing ${executionDescription} in ${buildOrder.length} packages...`);
+            // Add detailed multi-project execution context for debug mode
+            if (runConfig.debug) {
+                var _runConfig_tree35, _runConfig_tree36;
+                logger.debug('MULTI_PROJECT_PLAN: Execution plan initialized | Total Packages: %d | Command: %s | Built-in: %s | Dry Run: %s | Parallel: %s', buildOrder.length, commandToRun, isBuiltInCommand, isDryRun, ((_runConfig_tree35 = runConfig.tree) === null || _runConfig_tree35 === void 0 ? void 0 : _runConfig_tree35.parallel) || false);
+                // Log package execution order with dependencies
+                logger.debug('MULTI_PROJECT_ORDER: Package execution sequence:');
+                buildOrder.forEach((pkgName, idx)=>{
+                    const pkgInfo = dependencyGraph.packages.get(pkgName);
+                    if (pkgInfo) {
+                        const deps = Array.isArray(pkgInfo.dependencies) ? pkgInfo.dependencies : [];
+                        const depStr = deps.length > 0 ? ` | Dependencies: [${deps.join(', ')}]` : ' | Dependencies: none';
+                        logger.debug('  %d. %s%s', idx + 1, pkgName, depStr);
+                    }
+                });
+                // Log dependency levels for parallel execution understanding
+                const levels = new Map();
+                const calculateLevels = (pkg, visited = new Set())=>{
+                    if (levels.has(pkg)) return levels.get(pkg);
+                    if (visited.has(pkg)) return 0; // Circular dependency
+                    visited.add(pkg);
+                    const pkgInfo = dependencyGraph.packages.get(pkg);
+                    const deps = Array.isArray(pkgInfo === null || pkgInfo === void 0 ? void 0 : pkgInfo.dependencies) ? pkgInfo.dependencies : [];
+                    if (!pkgInfo || deps.length === 0) {
+                        levels.set(pkg, 0);
+                        return 0;
+                    }
+                    const maxDepLevel = Math.max(...deps.map((dep)=>calculateLevels(dep, new Set(visited))));
+                    const level = maxDepLevel + 1;
+                    levels.set(pkg, level);
+                    return level;
+                };
+                buildOrder.forEach((pkg)=>calculateLevels(pkg));
+                const maxLevel = Math.max(...Array.from(levels.values()));
+                logger.debug('MULTI_PROJECT_LEVELS: Dependency depth analysis | Max Depth: %d levels', maxLevel + 1);
+                for(let level = 0; level <= maxLevel; level++){
+                    const packagesAtLevel = buildOrder.filter((pkg)=>levels.get(pkg) === level);
+                    logger.debug('  Level %d (%d packages): %s', level, packagesAtLevel.length, packagesAtLevel.join(', '));
+                }
+                if ((_runConfig_tree36 = runConfig.tree) === null || _runConfig_tree36 === void 0 ? void 0 : _runConfig_tree36.parallel) {
+                    var _runConfig_tree_retry1;
+                    const os = await import('os');
+                    const concurrency = runConfig.tree.maxConcurrency || os.cpus().length;
+                    logger.debug('MULTI_PROJECT_PARALLEL: Parallel execution configuration | Max Concurrency: %d | Retry Attempts: %d', concurrency, ((_runConfig_tree_retry1 = runConfig.tree.retry) === null || _runConfig_tree_retry1 === void 0 ? void 0 : _runConfig_tree_retry1.maxAttempts) || 3);
+                }
+                if (isContinue) {
+                    const completed = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.completedPackages.length) || 0;
+                    logger.debug('MULTI_PROJECT_RESUME: Continuing previous execution | Completed: %d | Remaining: %d', completed, buildOrder.length - completed);
+                }
+            }
+            // 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;
+            // Check if parallel execution is enabled
+            if ((_runConfig_tree34 = runConfig.tree) === null || _runConfig_tree34 === void 0 ? void 0 : _runConfig_tree34.parallel) {
+                var _runConfig_tree_retry2, _runConfig_tree_retry3, _runConfig_tree_retry4, _runConfig_tree_retry5;
+                logger.info('🚀 Using parallel execution mode');
+                // If dry run, show preview instead of executing
+                if (isDryRun) {
+                    const preview = await generateDryRunPreview(dependencyGraph, buildOrder, commandToRun, runConfig);
+                    return preview;
+                }
+                // Import parallel execution components
+                const { TreeExecutionAdapter, createParallelProgressLogger, formatParallelResult } = await import('@eldrforge/tree-execution');
+                const os = await import('os');
+                // Create task pool
+                const adapter = new TreeExecutionAdapter({
+                    graph: dependencyGraph,
+                    maxConcurrency: runConfig.tree.maxConcurrency || os.cpus().length,
+                    command: commandToRun,
+                    config: runConfig,
+                    checkpointPath: runConfig.outputDirectory,
+                    continue: isContinue,
+                    maxRetries: ((_runConfig_tree_retry2 = runConfig.tree.retry) === null || _runConfig_tree_retry2 === void 0 ? void 0 : _runConfig_tree_retry2.maxAttempts) || 3,
+                    initialRetryDelay: ((_runConfig_tree_retry3 = runConfig.tree.retry) === null || _runConfig_tree_retry3 === void 0 ? void 0 : _runConfig_tree_retry3.initialDelayMs) || 5000,
+                    maxRetryDelay: ((_runConfig_tree_retry4 = runConfig.tree.retry) === null || _runConfig_tree_retry4 === void 0 ? void 0 : _runConfig_tree_retry4.maxDelayMs) || 60000,
+                    backoffMultiplier: ((_runConfig_tree_retry5 = runConfig.tree.retry) === null || _runConfig_tree_retry5 === void 0 ? void 0 : _runConfig_tree_retry5.backoffMultiplier) || 2
+                }, executePackage);
+                // Set up progress logging
+                createParallelProgressLogger(adapter.getPool(), runConfig);
+                // Execute
+                const result = await adapter.execute();
+                // Format and return result
+                const formattedResult = formatParallelResult(result);
+                return formattedResult;
+            }
+            // Sequential execution
+            const executionStartTime = Date.now();
+            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, allPackageNames, isBuiltInCommand);
+                if (result.success) {
+                    successCount++;
+                    // Update context
+                    if (executionContext && isBuiltInCommand && (builtInCommand === 'publish' || builtInCommand === 'run') && !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, packageInfo, i + 1, buildOrder.length);
+                    if (!isDryRun) {
+                        var _result_error;
+                        packageLogger.error(`Execution failed`);
+                        logger.error(formattedError);
+                        logger.error(`Failed after ${successCount} successful packages.`);
+                        // Special handling for timeout errors
+                        if (result.isTimeoutError) {
+                            logger.error('');
+                            logger.error('⏰ TIMEOUT DETECTED: This appears to be a timeout error.');
+                            logger.error('   This commonly happens when PR checks take longer than expected.');
+                            logger.error('   The execution context has been saved for recovery.');
+                            logger.error('');
+                            // Save context even on timeout for recovery
+                            if (executionContext && isBuiltInCommand && (builtInCommand === 'publish' || builtInCommand === 'run')) {
+                                executionContext.completedPackages.push(packageName);
+                                executionContext.publishedVersions = publishedVersions;
+                                executionContext.lastUpdateTime = new Date();
+                                await saveExecutionContext(executionContext, runConfig.outputDirectory);
+                                logger.info('💾 Execution context saved for recovery.');
+                            }
+                            // For publish commands, provide specific guidance about CI/CD setup
+                            if (builtInCommand === 'publish') {
+                                logger.error('');
+                                logger.error('💡 PUBLISH TIMEOUT TROUBLESHOOTING:');
+                                logger.error('   This project may not have CI/CD workflows configured.');
+                                logger.error('   Common solutions:');
+                                logger.error('   1. Set up GitHub Actions workflows for this repository');
+                                logger.error('   2. Use --sendit flag to skip user confirmation:');
+                                logger.error(`      kodrdriv tree publish --sendit`);
+                                logger.error('   3. Or manually promote this package:');
+                                logger.error(`      kodrdriv tree publish --promote ${packageName}`);
+                                logger.error('');
+                            }
+                        }
+                        logger.error(`To resume from this point, run:`);
+                        if (isBuiltInCommand) {
+                            logger.error(`    kodrdriv tree ${builtInCommand} --continue`);
+                        } else {
+                            logger.error(`    kodrdriv tree --continue --cmd "${commandToRun}"`);
+                        }
+                        // For timeout errors, provide additional recovery instructions
+                        if (result.isTimeoutError) {
+                            logger.error('');
+                            logger.error('🔧 RECOVERY OPTIONS:');
+                            if (builtInCommand === 'publish') {
+                                logger.error('   1. Wait for the PR checks to complete, then run:');
+                                logger.error(`      cd ${packageInfo.path}`);
+                                logger.error(`      kodrdriv publish`);
+                                logger.error('   2. After the individual publish completes, run:');
+                                logger.error(`      kodrdriv tree ${builtInCommand} --continue`);
+                            } else {
+                                logger.error('   1. Fix any issues in the package, then run:');
+                                logger.error(`      cd ${packageInfo.path}`);
+                                logger.error(`      ${commandToRun}`);
+                                logger.error('   2. After the command completes successfully, run:');
+                                logger.error(`      kodrdriv tree ${builtInCommand} --continue`);
+                            }
+                            logger.error('   3. Or promote this package to completed status:');
+                            logger.error(`      kodrdriv tree ${builtInCommand} --promote ${packageName}`);
+                            logger.error('   4. Or manually edit .kodrdriv-context to mark this package as completed');
+                        }
+                        // Add clear error summary at the very end
+                        logger.error('');
+                        logger.error('📋 ERROR SUMMARY:');
+                        logger.error(`   Project that failed: ${packageName}`);
+                        logger.error(`   Location: ${packageInfo.path}`);
+                        logger.error(`   Position in tree: ${i + 1} of ${buildOrder.length} packages`);
+                        logger.error(`   What failed: ${((_result_error = result.error) === null || _result_error === void 0 ? void 0 : _result_error.message) || 'Unknown error'}`);
+                        logger.error('');
+                        throw new Error(`Command failed in package ${packageName}`);
+                    }
+                    break;
+                }
+            }
+            if (!failedPackage) {
+                const totalExecutionTime = Date.now() - executionStartTime;
+                const totalSeconds = (totalExecutionTime / 1000).toFixed(1);
+                const totalMinutes = (totalExecutionTime / 60000).toFixed(1);
+                const timeDisplay = totalExecutionTime < 60000 ? `${totalSeconds}s` : `${totalMinutes}min (${totalSeconds}s)`;
+                logger.info('');
+                logger.info('═══════════════════════════════════════════════════════════');
+                const summary = `${isDryRun ? 'DRY RUN: ' : ''}All ${buildOrder.length} packages completed successfully! 🎉`;
+                logger.info(summary);
+                logger.info(`⏱️  Total execution time: ${timeDisplay}`);
+                logger.info(`📦 Packages processed: ${successCount}/${buildOrder.length}`);
+                logger.info('═══════════════════════════════════════════════════════════');
+                logger.info('');
+                // Clean up context on successful completion
+                if (isBuiltInCommand && (builtInCommand === 'publish' || builtInCommand === 'run') && !isDryRun) {
+                    await cleanupContext(runConfig.outputDirectory);
+                }
+                return returnOutput; // Don't duplicate the summary in return string
+            }
+        }
+        return returnOutput;
+    } catch (error) {
+        const errorMessage = `Failed to analyze workspace: ${error.message}`;
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+    } finally{
+    // 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.
+    }
+};
+
+/**
+ * Discover all package.json files in the workspace
+ */ const discoverPackages = async (directories, logger)=>{
+    const storage = createStorage();
+    const packages = [];
+    for (const directory of directories){
+        logger.verbose(`Scanning directory: ${directory}`);
+        try {
+            const packageJsonPath = path.join(directory, 'package.json');
+            if (await storage.exists(packageJsonPath)) {
+                const packageJsonContent = await storage.readFile(packageJsonPath, 'utf-8');
+                const parsed = safeJsonParse(packageJsonContent, packageJsonPath);
+                const packageJson = validatePackageJson(parsed, packageJsonPath);
+                if (packageJson.name) {
+                    packages.push({
+                        name: packageJson.name,
+                        version: packageJson.version,
+                        packageJsonPath
+                    });
+                    logger.verbose(`Found package: ${packageJson.name}@${packageJson.version}`);
+                }
+            } else {
+                // Look for nested package.json files in subdirectories
+                try {
+                    const entries = await fs.readdir(directory, {
+                        withFileTypes: true
+                    });
+                    for (const entry of entries){
+                        if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                            const subDir = path.join(directory, entry.name);
+                            const subPackages = await discoverPackages([
+                                subDir
+                            ], logger);
+                            packages.push(...subPackages);
+                        }
+                    }
+                } catch (error) {
+                    logger.debug(`Could not scan subdirectories in ${directory}: ${error}`);
+                }
+            }
+        } catch (error) {
+            logger.warn(`VERSIONS_DIR_PROCESS_FAILED: Failed to process directory | Directory: ${directory} | Error: ${error.message}`);
+        }
+    }
+    return packages;
+};
+/**
+ * Extract scope from package name (e.g., "@eldrforge/package" -> "@eldrforge")
+ */ const getPackageScope = (packageName)=>{
+    if (packageName.startsWith('@')) {
+        const parts = packageName.split('/');
+        if (parts.length >= 2) {
+            return parts[0];
+        }
+    }
+    return null;
+};
+/**
+ * Normalize version string to major.minor format (remove patch version)
+ */ const normalizeToMinorVersion = (versionString)=>{
+    // Extract the version number, preserving any prefix (^, ~, >=, etc.)
+    const match = versionString.match(/^([^0-9]*)([0-9]+\.[0-9]+)(\.[0-9]+)?(.*)$/);
+    if (match) {
+        const [, prefix, majorMinor, , suffix] = match;
+        return `${prefix}${majorMinor}${suffix || ''}`;
+    }
+    // If it doesn't match the expected pattern, return as-is
+    return versionString;
+};
+/**
+ * Update dependencies in a package.json to normalize same-scope dependencies to major.minor format
+ */ const updateDependenciesMinor = async (packageInfo, allPackages, isDryRun, logger)=>{
+    const storage = createStorage();
+    const currentScope = getPackageScope(packageInfo.name);
+    if (!currentScope) {
+        logger.verbose(`Skipping ${packageInfo.name} - not a scoped package`);
+        return false;
+    }
+    logger.verbose(`Processing ${packageInfo.name} for scope ${currentScope}`);
+    try {
+        const packageJsonContent = await storage.readFile(packageInfo.packageJsonPath, 'utf-8');
+        const parsed = safeJsonParse(packageJsonContent, packageInfo.packageJsonPath);
+        const packageJson = validatePackageJson(parsed, packageInfo.packageJsonPath);
+        const sectionsToUpdate = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies'
+        ];
+        let hasChanges = false;
+        // Create a set of same-scope package names for quick lookup
+        const sameScopePackageNames = new Set();
+        for (const pkg of allPackages){
+            const pkgScope = getPackageScope(pkg.name);
+            if (pkgScope === currentScope) {
+                sameScopePackageNames.add(pkg.name);
+            }
+        }
+        for (const section of sectionsToUpdate){
+            const deps = packageJson[section];
+            if (!deps) continue;
+            for (const [depName, currentVersion] of Object.entries(deps)){
+                // Update if this is a same-scope dependency (check scope, not just discovered packages)
+                const depScope = getPackageScope(depName);
+                if (depScope === currentScope) {
+                    const normalizedVersion = normalizeToMinorVersion(currentVersion);
+                    if (currentVersion !== normalizedVersion) {
+                        if (isDryRun) {
+                            logger.info(`VERSIONS_WOULD_NORMALIZE: Would normalize dependency version | Mode: dry-run | Section: ${section} | Dependency: ${depName} | Current: ${currentVersion} | Normalized: ${normalizedVersion}`);
+                        } else {
+                            logger.info(`VERSIONS_NORMALIZING: Normalizing dependency version | Section: ${section} | Dependency: ${depName} | Current: ${currentVersion} | Normalized: ${normalizedVersion}`);
+                            deps[depName] = normalizedVersion;
+                        }
+                        hasChanges = true;
+                    }
+                }
+            }
+        }
+        if (hasChanges && !isDryRun) {
+            // Write updated package.json
+            await storage.writeFile(packageInfo.packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+            logger.info(`VERSIONS_PACKAGE_UPDATED: Updated dependencies in package | Package: ${packageInfo.name} | Status: saved`);
+        }
+        return hasChanges;
+    } catch (error) {
+        logger.warn(`VERSIONS_PACKAGE_UPDATE_FAILED: Failed to update dependencies | Package: ${packageInfo.name} | Error: ${error.message}`);
+        return false;
+    }
+};
+/**
+ * Execute the versions minor command
+ */ const executeMinor = async (runConfig)=>{
+    var _runConfig_versions;
+    const logger = getLogger();
+    const isDryRun = runConfig.dryRun || false;
+    logger.info('VERSIONS_NORMALIZE_STARTING: Normalizing same-scope dependencies | Format: major.minor | Purpose: Standardize version format across packages');
+    // Determine directories to scan
+    const directories = ((_runConfig_versions = runConfig.versions) === null || _runConfig_versions === void 0 ? void 0 : _runConfig_versions.directories) || runConfig.contextDirectories || [
+        process.cwd()
+    ];
+    if (directories.length === 0) {
+        directories.push(process.cwd());
+    }
+    logger.verbose(`Scanning directories: ${directories.join(', ')}`);
+    // Discover all packages
+    const allPackages = await discoverPackages(directories, logger);
+    if (allPackages.length === 0) {
+        var _runConfig_tree;
+        logger.warn('VERSIONS_NO_PACKAGES: No packages found in specified directories | Directories: ' + (((_runConfig_tree = runConfig.tree) === null || _runConfig_tree === void 0 ? void 0 : _runConfig_tree.directories) || []).join(', ') + ' | Action: Nothing to normalize');
+        return 'No packages found to process.';
+    }
+    logger.info(`VERSIONS_PACKAGES_FOUND: Found packages for normalization | Count: ${allPackages.length} | Status: Analyzing`);
+    // Group packages by scope
+    const packagesByScope = new Map();
+    const unscopedPackages = [];
+    for (const pkg of allPackages){
+        const scope = getPackageScope(pkg.name);
+        if (scope) {
+            if (!packagesByScope.has(scope)) {
+                packagesByScope.set(scope, []);
+            }
+            packagesByScope.get(scope).push(pkg);
+        } else {
+            unscopedPackages.push(pkg);
+        }
+    }
+    logger.info(`VERSIONS_SCOPES_FOUND: Found package scopes | Count: ${packagesByScope.size} | Scopes: ${Array.from(packagesByScope.keys()).join(', ')}`);
+    if (unscopedPackages.length > 0) {
+        logger.info(`VERSIONS_UNSCOPED_PACKAGES: Found unscoped packages | Count: ${unscopedPackages.length} | Action: Will be skipped | Reason: Only scoped packages supported`);
+        // Log each unscoped package being skipped
+        for (const pkg of unscopedPackages){
+            logger.verbose(`Skipping ${pkg.name} - not a scoped package`);
+        }
+    }
+    let totalUpdated = 0;
+    let totalChanges = 0;
+    // Process each scope
+    for (const [scope, packages] of packagesByScope){
+        logger.info(`\nVERSIONS_SCOPE_PROCESSING: Processing packages in scope | Scope: ${scope} | Package Count: ${packages.length} | Action: Normalize versions`);
+        for (const pkg of packages){
+            const hasChanges = await updateDependenciesMinor(pkg, allPackages, isDryRun, logger);
+            if (hasChanges) {
+                totalChanges++;
+            }
+        }
+        totalUpdated += packages.length;
+    }
+    const verb = isDryRun ? 'Would update' : 'Updated';
+    const summary = `${verb} ${totalChanges} of ${totalUpdated} packages with dependency changes.`;
+    if (isDryRun) {
+        logger.info(`\nVERSIONS_DRY_RUN_COMPLETE: Dry run completed | Mode: dry-run | Summary: ${summary}`);
+        return `Dry run complete. ${summary}`;
+    } else {
+        logger.info(`\nVERSIONS_UPDATE_COMPLETE: Dependencies updated successfully | Status: completed | Summary: ${summary}`);
+        return `Dependencies updated successfully. ${summary}`;
+    }
+};
+/**
+ * Main execute function for the versions command
+ */ const execute = async (runConfig)=>{
+    var _runConfig_versions;
+    const subcommand = (_runConfig_versions = runConfig.versions) === null || _runConfig_versions === void 0 ? void 0 : _runConfig_versions.subcommand;
+    if (!subcommand) {
+        throw new Error('Versions command requires a subcommand. Use: kodrdriv versions minor');
+    }
+    switch(subcommand){
+        case 'minor':
+            return await executeMinor(runConfig);
+        default:
+            throw new Error(`Unknown versions subcommand: ${subcommand}. Supported: minor`);
+    }
+};
+
+// Check if npm install is needed by examining lock file and node_modules
+const isNpmInstallNeeded = async (storage)=>{
+    const logger = getLogger();
+    const timer = PerformanceTimer.start(logger, 'Checking if npm install is needed');
+    try {
+        // Check if package-lock.json exists
+        const hasLockFile = await storage.exists('package-lock.json');
+        if (!hasLockFile) {
+            timer.end('npm install needed - no lock file');
+            return {
+                needed: true,
+                reason: 'No package-lock.json found'
+            };
+        }
+        // Check if node_modules exists
+        const hasNodeModules = await storage.exists('node_modules');
+        if (!hasNodeModules) {
+            timer.end('npm install needed - no node_modules');
+            return {
+                needed: true,
+                reason: 'No node_modules directory found'
+            };
+        }
+        // Check if node_modules is populated (has at least a few entries)
+        const nodeModulesContents = await storage.listFiles('node_modules');
+        if (nodeModulesContents.length < 3) {
+            timer.end('npm install needed - empty node_modules');
+            return {
+                needed: true,
+                reason: 'node_modules appears empty or incomplete'
+            };
+        }
+        // Get timestamps to check if package.json is newer than node_modules
+        const packageJsonStats = await storage.exists('package.json');
+        if (!packageJsonStats) {
+            timer.end('npm install not needed - no package.json');
+            return {
+                needed: false,
+                reason: 'No package.json found'
+            };
+        }
+        timer.end('npm install not needed - appears up to date');
+        return {
+            needed: false,
+            reason: 'Dependencies appear to be up to date'
+        };
+    } catch (error) {
+        timer.end(`npm install check failed: ${error.message}`);
+        logger.debug(`Failed to check npm install status: ${error.message}`);
+        return {
+            needed: true,
+            reason: 'Could not verify dependency status, installing to be safe'
+        };
+    }
+};
+// Run npm install with optimizations
+const optimizedNpmInstall = async (options = {})=>{
+    const logger = getLogger();
+    const { createStorage } = await import('@eldrforge/shared');
+    const storage = createStorage();
+    const { skipIfNotNeeded = true, useCache = true, verbose = false } = options;
+    // Check if install is needed
+    if (skipIfNotNeeded) {
+        const installCheck = await isNpmInstallNeeded(storage);
+        if (!installCheck.needed) {
+            logger.info(`NPM_INSTALL_SKIPPED: Skipping npm install optimization | Reason: ${installCheck.reason} | Status: not-needed`);
+            return {
+                duration: 0,
+                skipped: true,
+                reason: installCheck.reason
+            };
+        } else {
+            logger.verbose(`📦 npm install required: ${installCheck.reason}`);
+        }
+    }
+    // Build optimized npm install command
+    const npmArgs = [
+        'install'
+    ];
+    if (!verbose) {
+        npmArgs.push('--silent');
+    }
+    if (useCache) {
+        // npm uses cache by default, but we can ensure it's not bypassed
+        npmArgs.push('--prefer-offline');
+    }
+    // Use --no-audit and --no-fund for faster installs in link/unlink scenarios
+    npmArgs.push('--no-audit', '--no-fund');
+    const command = `npm ${npmArgs.join(' ')}`;
+    logger.info(`NPM_INSTALL_OPTIMIZED: Running optimized npm install | Mode: optimized | Command: npm install`);
+    logger.verbose(`Command: ${command}`);
+    const timer = PerformanceTimer.start(logger, 'Optimized npm install execution');
+    try {
+        await run(command);
+        const duration = timer.end('Optimized npm install completed successfully');
+        logger.info(`NPM_INSTALL_SUCCESS: Dependencies installed successfully | Duration: ${duration}ms | Status: completed`);
+        return {
+            duration,
+            skipped: false,
+            reason: 'Installation completed successfully'
+        };
+    } catch (error) {
+        timer.end('Optimized npm install failed');
+        throw new Error(`Failed to run optimized npm install: ${error.message}`);
+    }
+};
+// Helper to run npm ci if package-lock.json is available (faster than npm install)
+const tryNpmCi = async ()=>{
+    const logger = getLogger();
+    const { createStorage } = await import('@eldrforge/shared');
+    const storage = createStorage();
+    try {
+        // Check if package-lock.json exists
+        const hasLockFile = await storage.exists('package-lock.json');
+        if (!hasLockFile) {
+            return {
+                success: false
+            };
+        }
+        logger.info('NPM_CI_USING: Using npm ci for faster installation | Command: npm ci | Advantage: Faster clean install');
+        const timer = PerformanceTimer.start(logger, 'npm ci execution');
+        await run('npm ci --silent --no-audit --no-fund');
+        const duration = timer.end('npm ci completed successfully');
+        logger.info(`NPM_CI_SUCCESS: Dependencies installed with npm ci | Duration: ${duration}ms | Status: completed`);
+        return {
+            success: true,
+            duration
+        };
+    } catch (error) {
+        logger.verbose(`npm ci failed, will fall back to npm install: ${error.message}`);
+        return {
+            success: false
+        };
+    }
+};
+// Main function that tries the fastest approach first
+const smartNpmInstall = async (options = {})=>{
+    const logger = getLogger();
+    const { skipIfNotNeeded = true, preferCi = true, verbose = false } = options;
+    const overallTimer = PerformanceTimer.start(logger, 'Smart npm install');
+    // Try npm ci first if preferred and available
+    if (preferCi) {
+        const ciResult = await tryNpmCi();
+        if (ciResult.success) {
+            overallTimer.end('Smart npm install completed with npm ci');
+            return {
+                duration: ciResult.duration || 0,
+                method: 'npm ci',
+                skipped: false
+            };
+        }
+    }
+    // Fall back to optimized npm install
+    const installResult = await optimizedNpmInstall({
+        skipIfNotNeeded,
+        useCache: true,
+        verbose
+    });
+    overallTimer.end(`Smart npm install completed with ${installResult.skipped ? 'skip' : 'npm install'}`);
+    return {
+        duration: installResult.duration,
+        method: installResult.skipped ? 'skipped' : 'npm install',
+        skipped: installResult.skipped
+    };
+};
+
+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;
+}
+/**
+ * PerformanceTracker collects and analyzes performance metrics
+ */ class PerformanceTracker {
+    /**
+     * Record package start
+     */ recordPackageStart(packageName) {
+        this.packageStartTimes.set(packageName, Date.now());
+    }
+    /**
+     * Record package end
+     */ recordPackageEnd(packageName) {
+        this.packageEndTimes.set(packageName, Date.now());
+    }
+    /**
+     * Record concurrency level
+     */ recordConcurrency(level) {
+        this.concurrencyHistory.push(level);
+    }
+    /**
+     * Calculate comprehensive metrics
+     */ calculateMetrics(_maxConcurrency) {
+        const totalDuration = Date.now() - this.startTime;
+        const durations = this.getPackageDurations();
+        const averageDuration = durations.length > 0 ? durations.reduce((a, b)=>a + b, 0) / durations.length : 0;
+        const peakConcurrency = this.concurrencyHistory.length > 0 ? Math.max(...this.concurrencyHistory) : 0;
+        const averageConcurrency = this.concurrencyHistory.length > 0 ? this.concurrencyHistory.reduce((a, b)=>a + b, 0) / this.concurrencyHistory.length : 0;
+        // Calculate speedup vs sequential
+        const totalCPUTime = durations.reduce((a, b)=>a + b, 0);
+        const speedupVsSequential = totalDuration > 0 ? totalCPUTime / totalDuration : 1;
+        return {
+            totalDuration,
+            averagePackageDuration: averageDuration,
+            peakConcurrency,
+            averageConcurrency,
+            speedupVsSequential
+        };
+    }
+    /**
+     * Get package durations
+     */ getPackageDurations() {
+        const durations = [];
+        for (const [pkg, startTime] of this.packageStartTimes){
+            const endTime = this.packageEndTimes.get(pkg);
+            if (endTime) {
+                durations.push(endTime - startTime);
+            }
+        }
+        return durations;
+    }
+    /**
+     * Get efficiency metrics
+     */ getEfficiency(maxConcurrency) {
+        const durations = this.getPackageDurations();
+        const totalDuration = Date.now() - this.startTime;
+        const totalCPUTime = durations.reduce((a, b)=>a + b, 0);
+        const utilization = this.concurrencyHistory.length > 0 ? this.concurrencyHistory.reduce((a, b)=>a + b, 0) / this.concurrencyHistory.length / maxConcurrency * 100 : 0;
+        const efficiency = totalDuration > 0 ? totalCPUTime / (totalDuration * maxConcurrency) * 100 : 0;
+        const speedup = totalDuration > 0 ? totalCPUTime / totalDuration : 1;
+        const idealSpeedup = maxConcurrency;
+        const parallelEfficiency = speedup / idealSpeedup * 100;
+        return {
+            utilization,
+            efficiency,
+            parallelEfficiency
+        };
+    }
+    /**
+     * Generate performance report
+     */ generateReport(maxConcurrency) {
+        const metrics = this.calculateMetrics(maxConcurrency);
+        const efficiency = this.getEfficiency(maxConcurrency);
+        const durations = this.getPackageDurations();
+        const lines = [];
+        lines.push('');
+        lines.push('═══════════════════════════════════════════');
+        lines.push('        Performance Report');
+        lines.push('═══════════════════════════════════════════');
+        lines.push('');
+        lines.push('⏱️  Timing:');
+        lines.push(`  Total Execution:   ${this.formatDuration(metrics.totalDuration)}`);
+        lines.push(`  Avg Per Package:   ${this.formatDuration(metrics.averagePackageDuration)}`);
+        if (durations.length > 0) {
+            lines.push(`  Fastest Package:   ${this.formatDuration(Math.min(...durations))}`);
+            lines.push(`  Slowest Package:   ${this.formatDuration(Math.max(...durations))}`);
+        }
+        lines.push('');
+        lines.push('🔥 Concurrency:');
+        lines.push(`  Max Allowed:       ${maxConcurrency}`);
+        lines.push(`  Peak Reached:      ${metrics.peakConcurrency}`);
+        lines.push(`  Average:           ${metrics.averageConcurrency.toFixed(2)}`);
+        lines.push(`  Utilization:       ${efficiency.utilization.toFixed(1)}%`);
+        lines.push('');
+        lines.push('🚀 Performance:');
+        if (metrics.speedupVsSequential) {
+            lines.push(`  Speedup:           ${metrics.speedupVsSequential.toFixed(2)}x`);
+        }
+        lines.push(`  Efficiency:        ${efficiency.efficiency.toFixed(1)}%`);
+        lines.push(`  Parallel Efficiency: ${efficiency.parallelEfficiency.toFixed(1)}%`);
+        lines.push('');
+        const totalCPUTime = durations.reduce((a, b)=>a + b, 0);
+        const timeSaved = totalCPUTime - metrics.totalDuration;
+        if (timeSaved > 0) {
+            lines.push(`⏰ Time Saved: ${this.formatDuration(timeSaved)} vs sequential execution`);
+            lines.push('');
+        }
+        lines.push('═══════════════════════════════════════════');
+        lines.push('');
+        return lines.join('\n');
+    }
+    formatDuration(ms) {
+        if (ms < 1000) {
+            return `${ms}ms`;
+        }
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        return `${seconds}s`;
+    }
+    constructor(){
+        _define_property(this, "startTime", void 0);
+        _define_property(this, "packageStartTimes", new Map());
+        _define_property(this, "packageEndTimes", new Map());
+        _define_property(this, "concurrencyHistory", []);
+        this.startTime = Date.now();
+    }
+}
+
+export { PerformanceTracker, isNpmInstallNeeded, execute$4 as link, optimizedNpmInstall, smartNpmInstall, execute$1 as tree, tryNpmCi, execute$3 as unlink, execute$2 as updates, execute as versions };
+//# sourceMappingURL=index.js.map