@eldrforge/kodrdriv 1.2.26 → 1.2.28

package/dist/commands/publish.js

@@ -30,11 +30,11 @@ const scanNpmrcForEnvVars = async (storage)=>{
                 }
             }
         } catch (error) {
-            logger.warn(`Failed to read .npmrc file at ${npmrcPath}: ${error.message}`);
-            logger.verbose('This may affect environment variable detection for publishing');
+            logger.warn(`NPMRC_READ_FAILED: Unable to read .npmrc configuration file | Path: ${npmrcPath} | Error: ${error.message}`);
+            logger.verbose('NPMRC_READ_IMPACT: Environment variable detection for publishing may be affected due to failed .npmrc read');
         }
     } else {
-        logger.debug('.npmrc file not found, skipping environment variable scan');
+        logger.debug('NPMRC_NOT_FOUND: No .npmrc file present in current directory | Action: Skipping environment variable scan | Path: ' + npmrcPath);
     }
     return envVars;
 };
@@ -50,7 +50,7 @@ const scanNpmrcForEnvVars = async (storage)=>{
             await fs.access(packageLockPath);
         } catch  {
             // No package-lock.json, nothing to clean
-            logger.verbose('No package-lock.json found, skipping npm link cleanup');
+            logger.verbose('PACKAGE_LOCK_NOT_FOUND: No package-lock.json file exists | Action: Skipping npm link cleanup | Path: ' + packageLockPath);
             return;
         }
         // Read and parse package-lock.json
@@ -66,7 +66,7 @@ const scanNpmrcForEnvVars = async (storage)=>{
                     const resolvedPath = pkgInfo.resolved.replace('file:', '');
                     if (resolvedPath.startsWith('../') || resolvedPath.startsWith('./')) {
                         hasFileReferences = true;
-                        logger.verbose(`Found npm link reference: ${pkgPath} -> ${pkgInfo.resolved}`);
+                        logger.verbose(`NPM_LINK_DETECTED: Found npm link reference in packages section | Package: ${pkgPath} | Resolved: ${pkgInfo.resolved} | Type: relative_file_dependency`);
                         break;
                     }
                 }
@@ -79,33 +79,33 @@ const scanNpmrcForEnvVars = async (storage)=>{
                     const versionPath = pkgInfo.version.replace('file:', '');
                     if (versionPath.startsWith('../') || versionPath.startsWith('./')) {
                         hasFileReferences = true;
-                        logger.verbose(`Found npm link reference: ${pkgName} -> ${pkgInfo.version}`);
+                        logger.verbose(`NPM_LINK_DETECTED: Found npm link reference in dependencies section | Package: ${pkgName} | Version: ${pkgInfo.version} | Type: relative_file_dependency`);
                         break;
                     }
                 }
             }
         }
         if (hasFileReferences) {
-            logger.info('⚠️  Detected npm link references in package-lock.json');
-            logger.info('🧹 Cleaning up package-lock.json to remove relative file: dependencies...');
+            logger.info('NPM_LINK_CLEANUP_REQUIRED: Detected npm link references in package-lock.json | File: package-lock.json | Impact: Must be cleaned before publish');
+            logger.info('NPM_LINK_CLEANUP_STARTING: Removing package-lock.json and regenerating clean version | Action: Remove file with relative dependencies');
             if (isDryRun) {
-                logger.info('DRY RUN: Would remove package-lock.json and regenerate it');
+                logger.info('DRY_RUN_OPERATION: Would remove package-lock.json and regenerate it | Mode: dry-run | File: package-lock.json');
             } else {
                 // Remove package-lock.json
                 await fs.unlink(packageLockPath);
-                logger.verbose('Removed package-lock.json with npm link references');
+                logger.verbose('NPM_LINK_CLEANUP_FILE_REMOVED: Deleted package-lock.json containing npm link references | Path: ' + packageLockPath);
                 // Regenerate clean package-lock.json
-                logger.verbose('Regenerating package-lock.json from package.json...');
+                logger.verbose('NPM_LOCK_REGENERATING: Executing npm install to regenerate package-lock.json from package.json | Command: npm install --package-lock-only --no-audit --no-fund');
                 await runWithDryRunSupport('npm install --package-lock-only --no-audit --no-fund', isDryRun);
-                logger.info('✅ Regenerated clean package-lock.json');
+                logger.info('NPM_LOCK_REGENERATED: Successfully regenerated clean package-lock.json without link references | Path: ' + packageLockPath);
             }
         } else {
-            logger.verbose('No npm link references found in package-lock.json');
+            logger.verbose('NPM_LINK_CHECK_CLEAN: No npm link references found in package-lock.json | Status: Ready for publish | File: ' + packageLockPath);
         }
     } catch (error) {
         // Log warning but don't fail - let npm update handle any issues
-        logger.warn(`⚠️  Failed to check/clean npm link references: ${error.message}`);
-        logger.verbose('Continuing with publish process...');
+        logger.warn(`NPM_LINK_CHECK_FAILED: Unable to check or clean npm link references | Error: ${error.message} | Impact: Continuing with publish, npm will handle issues`);
+        logger.verbose('PUBLISH_PROCESS_CONTINUING: Proceeding with publish workflow despite npm link check failure | Next: Standard npm publish validation');
     }
 };
 const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
@@ -118,9 +118,9 @@ const validateEnvironmentVariables = (requiredEnvVars, isDryRun)=>{
     }
     if (missingEnvVars.length > 0) {
         if (isDryRun) {
-            logger.warn(`Missing required environment variables: ${missingEnvVars.join(', ')}`);
+            logger.warn(`ENV_VARS_MISSING: Required environment variables not set | Variables: ${missingEnvVars.join(', ')} | Mode: dry-run | Impact: Would fail in real publish`);
         } else {
-            logger.error(`Missing required environment variables: ${missingEnvVars.join(', ')}`);
+            logger.error(`ENV_VARS_MISSING: Required environment variables not set | Variables: ${missingEnvVars.join(', ')} | Action: Must set before publish | Source: .npmrc configuration`);
             throw new Error(`Missing required environment variables: ${missingEnvVars.join(', ')}. Please set these environment variables before running publish.`);
         }
     }
@@ -132,11 +132,11 @@ const runPrechecks = async (runConfig, targetBranch)=>{
     const storage = create({
         log: logger.info
     });
-    logger.info('Running prechecks...');
+    logger.info('PRECHECK_STARTING: Executing publish prechecks | Phase: validation | Target: ' + (targetBranch || 'default'));
     // Check if we're in a git repository
     try {
         if (isDryRun) {
-            logger.info('Would check git repository with: git rev-parse --git-dir');
+            logger.info('PRECHECK_GIT_REPO: Would verify git repository | Mode: dry-run | Command: git rev-parse --git-dir');
         } else {
             await run('git rev-parse --git-dir');
         }
@@ -148,10 +148,10 @@ const runPrechecks = async (runConfig, targetBranch)=>{
         }
     }
     // Check for uncommitted changes
-    logger.info('Checking for uncommitted changes...');
+    logger.info('PRECHECK_GIT_STATUS: Checking for uncommitted changes | Command: git status --porcelain | Requirement: Clean working directory');
     try {
         if (isDryRun) {
-            logger.info('Would check git status with: git status --porcelain');
+            logger.info('PRECHECK_GIT_STATUS: Would verify clean working directory | Mode: dry-run | Command: git status --porcelain');
         } else {
             const { stdout } = await run('git status --porcelain');
             if (stdout.trim()) {
@@ -168,9 +168,9 @@ const runPrechecks = async (runConfig, targetBranch)=>{
     // Use the passed target branch or fallback to config/default
     const effectiveTargetBranch = targetBranch || ((_runConfig_publish = runConfig.publish) === null || _runConfig_publish === void 0 ? void 0 : _runConfig_publish.targetBranch) || 'main';
     // Check that we're not running from the target branch
-    logger.info('Checking current branch...');
+    logger.info('PRECHECK_BRANCH: Verifying current branch is not target branch | Target: ' + effectiveTargetBranch + ' | Requirement: Must run from feature branch');
     if (isDryRun) {
-        logger.info(`Would verify current branch is not the target branch (${effectiveTargetBranch})`);
+        logger.info(`PRECHECK_BRANCH: Would verify current branch is not target branch | Mode: dry-run | Target: ${effectiveTargetBranch}`);
     } else {
         const currentBranch = await GitHub.getCurrentBranchName();
         if (currentBranch === effectiveTargetBranch) {
@@ -178,43 +178,42 @@ const runPrechecks = async (runConfig, targetBranch)=>{
         }
     }
     // Check target branch sync with remote
-    logger.info(`Checking target branch '${effectiveTargetBranch}' sync with remote...`);
+    logger.info(`PRECHECK_BRANCH_SYNC: Checking target branch sync with remote | Branch: ${effectiveTargetBranch} | Remote: origin | Requirement: Branches must be synchronized`);
     if (isDryRun) {
-        logger.info(`Would verify target branch '${effectiveTargetBranch}' is in sync with remote origin`);
+        logger.info(`PRECHECK_BRANCH_SYNC: Would verify target branch is in sync with remote | Mode: dry-run | Branch: ${effectiveTargetBranch} | Remote: origin`);
     } else {
         // Only check if local target branch exists (it's okay if it doesn't exist locally)
         const targetBranchExists = await localBranchExists(effectiveTargetBranch);
         if (targetBranchExists) {
             const syncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
             if (!syncStatus.inSync) {
-                logger.error(`❌ Target branch '${effectiveTargetBranch}' is not in sync with remote.`);
+                logger.error(`BRANCH_SYNC_FAILED: Target branch not synchronized with remote | Branch: ${effectiveTargetBranch} | Status: out-of-sync | Impact: Cannot proceed with publish`);
                 logger.error('');
                 if (syncStatus.error) {
-                    logger.error(`   Error: ${syncStatus.error}`);
+                    logger.error(`BRANCH_SYNC_ERROR: ${syncStatus.error}`);
                 } else if (syncStatus.localSha && syncStatus.remoteSha) {
-                    logger.error(`   Local:  ${syncStatus.localSha.substring(0, 8)}`);
-                    logger.error(`   Remote: ${syncStatus.remoteSha.substring(0, 8)}`);
+                    logger.error(`BRANCH_SYNC_DIVERGENCE: Local and remote commits differ | Local SHA: ${syncStatus.localSha.substring(0, 8)} | Remote SHA: ${syncStatus.remoteSha.substring(0, 8)}`);
                 }
                 logger.error('');
-                logger.error('📋 To resolve this issue:');
-                logger.error(`   1. Switch to the target branch: git checkout ${effectiveTargetBranch}`);
-                logger.error(`   2. Pull the latest changes: git pull origin ${effectiveTargetBranch}`);
-                logger.error('   3. Resolve any merge conflicts if they occur');
-                logger.error('   4. Switch back to your feature branch and re-run publish');
+                logger.error('RESOLUTION_STEPS: Manual intervention required to sync branches:');
+                logger.error(`   Step 1: Switch to target branch | Command: git checkout ${effectiveTargetBranch}`);
+                logger.error(`   Step 2: Pull latest changes | Command: git pull origin ${effectiveTargetBranch}`);
+                logger.error('   Step 3: Resolve merge conflicts if present');
+                logger.error('   Step 4: Return to feature branch and retry publish');
                 logger.error('');
-                logger.error('💡 Alternatively, run "kodrdriv publish --sync-target" to attempt automatic sync.');
+                logger.error(`ALTERNATIVE_OPTION: Automatic sync available | Command: kodrdriv publish --sync-target | Branch: ${effectiveTargetBranch}`);
                 throw new Error(`Target branch '${effectiveTargetBranch}' is not in sync with remote. Please sync the branch before running publish.`);
             } else {
-                logger.info(`✅ Target branch '${effectiveTargetBranch}' is in sync with remote.`);
+                logger.info(`BRANCH_SYNC_VERIFIED: Target branch is synchronized with remote | Branch: ${effectiveTargetBranch} | Status: in-sync`);
             }
         } else {
-            logger.info(`ℹ️  Target branch '${effectiveTargetBranch}' does not exist locally - will be created when needed.`);
+            logger.info(`BRANCH_NOT_LOCAL: Target branch does not exist locally | Branch: ${effectiveTargetBranch} | Action: Will be created during publish process`);
         }
     }
     // Check GitHub Actions workflow configuration
-    logger.info('Checking GitHub Actions workflow configuration...');
+    logger.info('PRECHECK_WORKFLOW: Checking GitHub Actions workflow configuration | Target: PR automation | Requirement: Workflows should trigger on pull requests');
     if (isDryRun) {
-        logger.info('Would check if GitHub Actions workflows are configured for pull requests');
+        logger.info('PRECHECK_WORKFLOW: Would check if GitHub Actions workflows are configured for pull requests | Mode: dry-run');
     } else {
         try {
             // TODO: Re-enable when checkWorkflowConfiguration is exported from github-tools
@@ -226,25 +225,25 @@ const runPrechecks = async (runConfig, targetBranch)=>{
                 triggeredWorkflowNames: []
             };
             if (!workflowConfig.hasWorkflows) ; else if (!workflowConfig.hasPullRequestTriggers) ; else {
-                logger.info(`✅ Found ${workflowConfig.triggeredWorkflowNames.length} workflow(s) that will run on PRs to ${effectiveTargetBranch}:`);
+                logger.info(`WORKFLOW_CONFIGURED: Found workflows that will trigger on pull requests | Target Branch: ${effectiveTargetBranch} | Workflow Count: ${workflowConfig.triggeredWorkflowNames.length}`);
                 for (const workflowName of workflowConfig.triggeredWorkflowNames){
-                    logger.info(`   - ${workflowName}`);
+                    logger.info(`WORKFLOW_ACTIVE: ${workflowName} | Trigger: pull_request | Target: ${effectiveTargetBranch}`);
                 }
             }
         } catch (error) {
             // Don't fail the precheck if we can't verify workflows
             // The wait logic will handle it later
-            logger.debug(`Could not verify workflow configuration: ${error.message}`);
+            logger.debug(`WORKFLOW_CHECK_FAILED: Unable to verify workflow configuration | Error: ${error.message} | Impact: Will proceed with publish | Note: Wait logic will handle checks later`);
         }
     }
     // Check if prepublishOnly script exists in package.json
-    logger.info('Checking for prepublishOnly script...');
+    logger.info('PRECHECK_PREPUBLISH: Checking for prepublishOnly script in package.json | Requirement: Must exist to run pre-flight checks | Expected: clean, lint, build, test');
     const packageJsonPath = path__default.join(process.cwd(), 'package.json');
     if (!await storage.exists(packageJsonPath)) {
         if (!isDryRun) {
             throw new Error('package.json not found in current directory.');
         } else {
-            logger.warn('package.json not found in current directory.');
+            logger.warn('PACKAGE_JSON_NOT_FOUND: No package.json in current directory | Mode: dry-run | Impact: Cannot verify prepublishOnly script | Path: ' + packageJsonPath);
         }
     } else {
         var _packageJson_scripts;
@@ -257,19 +256,19 @@ const runPrechecks = async (runConfig, targetBranch)=>{
             if (!isDryRun) {
                 throw new Error('Failed to parse package.json. Please ensure it contains valid JSON.');
             } else {
-                logger.warn('Failed to parse package.json. Please ensure it contains valid JSON.');
+                logger.warn('PACKAGE_JSON_PARSE_FAILED: Unable to parse package.json | Mode: dry-run | Impact: Cannot verify prepublishOnly script | Path: ' + packageJsonPath + ' | Requirement: Valid JSON format');
             }
         }
         if (packageJson && !((_packageJson_scripts = packageJson.scripts) === null || _packageJson_scripts === void 0 ? void 0 : _packageJson_scripts.prepublishOnly)) {
             if (!isDryRun) {
                 throw new Error('prepublishOnly script is required in package.json but was not found. Please add a prepublishOnly script that runs your pre-flight checks (e.g., clean, lint, build, test).');
             } else {
-                logger.warn('prepublishOnly script is required in package.json but was not found.');
+                logger.warn('PREPUBLISH_SCRIPT_MISSING: No prepublishOnly script found in package.json | Mode: dry-run | Requirement: Script must exist | Expected Tasks: clean, lint, build, test | Path: ' + packageJsonPath);
             }
         }
     }
     // Check required environment variables
-    logger.verbose('Checking required environment variables...');
+    logger.verbose('PRECHECK_ENV_VARS: Checking required environment variables | Source: Configuration and .npmrc | Requirement: All required vars must be set');
     const coreRequiredEnvVars = ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.requiredEnvVars) || [];
     const npmrcEnvVars = isDryRun ? [] : await scanNpmrcForEnvVars(storage); // Skip .npmrc scan in dry run
     const allRequiredEnvVars = [
@@ -279,12 +278,12 @@ const runPrechecks = async (runConfig, targetBranch)=>{
         ])
     ];
     if (allRequiredEnvVars.length > 0) {
-        logger.verbose(`Required environment variables: ${allRequiredEnvVars.join(', ')}`);
+        logger.verbose(`ENV_VARS_REQUIRED: Environment variables needed for publish | Variables: ${allRequiredEnvVars.join(', ')} | Count: ${allRequiredEnvVars.length} | Source: config + .npmrc`);
         validateEnvironmentVariables(allRequiredEnvVars, isDryRun);
     } else {
-        logger.verbose('No required environment variables specified.');
+        logger.verbose('ENV_VARS_NONE: No required environment variables specified | Status: No validation needed | Source: config + .npmrc');
     }
-    logger.info('All prechecks passed.');
+    logger.info('PRECHECK_COMPLETE: All publish prechecks passed successfully | Status: Ready to proceed | Next: Execute publish workflow');
 };
 // Helper: deep-sort object keys for stable comparison
 const sortObjectKeys = (value)=>{
@@ -315,7 +314,7 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
         ]);
     } catch (error) {
         // Target branch doesn't exist or isn't accessible
-        logger.verbose(`Target branch '${targetBranch}' does not exist or is not accessible. Proceeding with publish.`);
+        logger.verbose(`RELEASE_CHECK_NO_TARGET: Target branch does not exist or is not accessible | Branch: ${targetBranch} | Action: Proceeding with publish | Reason: First release to this branch`);
         return {
             necessary: true,
             reason: `Target branch '${targetBranch}' does not exist; first release to this branch`
@@ -362,9 +361,11 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
         const headSorted = sortObjectKeys(headWithoutVersion);
         const equalExceptVersion = JSON.stringify(baseSorted) === JSON.stringify(headSorted);
         if (equalExceptVersion) {
+            const currentVersion = headPkg.version;
+            const targetVersion = basePkg.version;
             return {
                 necessary: false,
-                reason: 'Only version changed in package.json (plus lockfile)'
+                reason: `No meaningful changes detected:\n   • Current version: ${currentVersion}\n   • Target branch version: ${targetVersion}\n   • Only package.json version field differs\n\n   To force republish: Add meaningful code changes or use --force (not yet implemented)`
             };
         }
         // Other fields changed inside package.json
@@ -374,7 +375,7 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
         };
     } catch (error) {
         // Conservative: if we cannot prove it is only a version change, proceed with release
-        logger.verbose(`Could not conclusively compare package.json changes: ${error.message}`);
+        logger.verbose(`RELEASE_CHECK_COMPARISON_FAILED: Unable to conclusively compare package.json changes | Error: ${error.message} | Action: Proceeding conservatively with publish | Reason: Cannot verify version-only change`);
         return {
             necessary: true,
             reason: 'Could not compare package.json safely'
@@ -384,27 +385,27 @@ const isReleaseNecessaryComparedToTarget = async (targetBranch, isDryRun)=>{
 const handleTargetBranchSyncRecovery = async (runConfig, targetBranch)=>{
     const isDryRun = runConfig.dryRun || false;
     const logger = getDryRunLogger(isDryRun);
-    logger.info(`🔄 Attempting to sync target branch '${targetBranch}' with remote...`);
+    logger.info(`BRANCH_SYNC_ATTEMPTING: Initiating sync of target branch with remote | Branch: ${targetBranch} | Remote: origin | Operation: fetch + merge`);
     if (isDryRun) {
-        logger.info(`Would attempt to sync '${targetBranch}' with remote`);
+        logger.info(`BRANCH_SYNC_DRY_RUN: Would attempt to sync branch with remote | Mode: dry-run | Branch: ${targetBranch} | Remote: origin`);
         return;
     }
     const syncResult = await safeSyncBranchWithRemote(targetBranch);
     if (syncResult.success) {
-        logger.info(`✅ Successfully synced '${targetBranch}' with remote.`);
-        logger.info('You can now re-run the publish command.');
+        logger.info(`BRANCH_SYNC_SUCCESS: Successfully synchronized branch with remote | Branch: ${targetBranch} | Remote: origin | Status: in-sync`);
+        logger.info('BRANCH_SYNC_NEXT_STEP: Ready to proceed with publish | Action: Re-run publish command | Branch: ' + targetBranch);
     } else if (syncResult.conflictResolutionRequired) {
-        logger.error(`❌ Failed to sync '${targetBranch}': conflicts detected.`);
+        logger.error(`BRANCH_SYNC_CONFLICTS: Sync failed due to merge conflicts | Branch: ${targetBranch} | Status: conflicts-detected | Resolution: Manual intervention required`);
         logger.error('');
-        logger.error('📋 Manual conflict resolution required:');
-        logger.error(`   1. Switch to the target branch: git checkout ${targetBranch}`);
-        logger.error(`   2. Pull and resolve conflicts: git pull origin ${targetBranch}`);
-        logger.error('   3. Commit the resolved changes');
-        logger.error('   4. Switch back to your feature branch and re-run publish');
+        logger.error('CONFLICT_RESOLUTION_STEPS: Manual conflict resolution required:');
+        logger.error(`   Step 1: Switch to target branch | Command: git checkout ${targetBranch}`);
+        logger.error(`   Step 2: Pull and resolve conflicts | Command: git pull origin ${targetBranch}`);
+        logger.error('   Step 3: Commit resolved changes | Command: git commit');
+        logger.error('   Step 4: Return to feature branch and retry | Command: kodrdriv publish');
         logger.error('');
         throw new Error(`Target branch '${targetBranch}' has conflicts that require manual resolution.`);
     } else {
-        logger.error(`❌ Failed to sync '${targetBranch}': ${syncResult.error}`);
+        logger.error(`BRANCH_SYNC_FAILED: Sync operation failed | Branch: ${targetBranch} | Error: ${syncResult.error} | Remote: origin`);
         throw new Error(`Failed to sync target branch: ${syncResult.error}`);
     }
 };
@@ -422,37 +423,38 @@ const execute = async (runConfig)=>{
     } else {
         currentBranch = await GitHub.getCurrentBranchName();
         // Fetch latest remote information to avoid conflicts
-        logger.info('📡 Fetching latest remote information to avoid conflicts...');
+        logger.info('GIT_FETCH_STARTING: Fetching latest remote information | Remote: origin | Purpose: Avoid conflicts during publish | Command: git fetch origin');
         try {
             await run('git fetch origin');
-            logger.info('✅ Fetched latest remote information');
+            logger.info('GIT_FETCH_SUCCESS: Successfully fetched latest remote information | Remote: origin | Status: up-to-date');
         } catch (error) {
-            logger.warn(`⚠️ Could not fetch from remote: ${error.message}`);
+            logger.warn(`GIT_FETCH_FAILED: Unable to fetch from remote | Remote: origin | Error: ${error.message} | Impact: May cause conflicts if remote has changes`);
         }
         // Sync current branch with remote to avoid conflicts
-        logger.info(`🔄 Syncing ${currentBranch} with remote to avoid conflicts...`);
+        logger.info(`CURRENT_BRANCH_SYNC: Synchronizing current branch with remote | Branch: ${currentBranch} | Remote: origin | Purpose: Avoid conflicts during publish`);
         try {
             const remoteExists = await run(`git ls-remote --exit-code --heads origin ${currentBranch}`).then(()=>true).catch(()=>false);
             if (remoteExists) {
-                // Wrap git pull with lock to prevent concurrent pulls in same repo
+                // Use explicit fetch+merge instead of pull to avoid git config conflicts
                 await runGitWithLock(process.cwd(), async ()=>{
-                    await run(`git pull origin ${currentBranch} --no-edit`);
-                }, `pull ${currentBranch}`);
-                logger.info(`✅ Synced ${currentBranch} with remote`);
+                    await run(`git fetch origin ${currentBranch}`);
+                    await run(`git merge origin/${currentBranch} --no-ff --no-edit`);
+                }, `sync ${currentBranch}`);
+                logger.info(`CURRENT_BRANCH_SYNCED: Successfully synchronized current branch with remote | Branch: ${currentBranch} | Remote: origin/${currentBranch} | Status: in-sync`);
             } else {
-                logger.info(`ℹ️ No remote ${currentBranch} branch found, will be created on first push`);
+                logger.info(`REMOTE_BRANCH_NOT_FOUND: No remote branch exists | Branch: ${currentBranch} | Remote: origin | Action: Will be created on first push`);
             }
         } catch (error) {
             if (error.message && error.message.includes('CONFLICT')) {
-                logger.error(`❌ Merge conflicts detected when syncing ${currentBranch} with remote`);
-                logger.error(`   Please resolve the conflicts manually and then run:`);
-                logger.error(`   1. Resolve conflicts in the files`);
-                logger.error(`   2. git add <resolved-files>`);
-                logger.error(`   3. git commit`);
-                logger.error(`   4. kodrdriv publish (to continue)`);
+                logger.error(`MERGE_CONFLICTS_DETECTED: Conflicts found when syncing current branch with remote | Branch: ${currentBranch} | Remote: origin/${currentBranch} | Status: conflicts-require-resolution`);
+                logger.error(`CONFLICT_RESOLUTION_REQUIRED: Manual intervention needed to resolve conflicts and continue:`);
+                logger.error(`   Step 1: Resolve conflicts in affected files`);
+                logger.error(`   Step 2: Stage resolved files | Command: git add <resolved-files>`);
+                logger.error(`   Step 3: Commit resolution | Command: git commit`);
+                logger.error(`   Step 4: Retry publish | Command: kodrdriv publish`);
                 throw new Error(`Merge conflicts detected when syncing ${currentBranch} with remote. Please resolve conflicts manually.`);
             } else {
-                logger.warn(`⚠️ Could not sync with remote ${currentBranch}: ${error.message}`);
+                logger.warn(`CURRENT_BRANCH_SYNC_FAILED: Unable to sync current branch with remote | Branch: ${currentBranch} | Remote: origin/${currentBranch} | Error: ${error.message} | Impact: May cause issues during publish`);
             }
         }
     }
@@ -466,19 +468,19 @@ const execute = async (runConfig)=>{
         if (branchConfig.targetBranch) {
             targetBranch = branchConfig.targetBranch;
         }
-        logger.info(`🎯 Branch-dependent targeting enabled:`);
-        logger.info(`   Source branch: ${currentBranch}`);
-        logger.info(`   Target branch: ${targetBranch}`);
+        logger.info(`BRANCH_DEPENDENT_TARGETING: Branch-specific configuration active | Source: ${currentBranch} | Target: ${targetBranch} | Feature: Branch-dependent versioning and targeting`);
+        logger.info(`BRANCH_CONFIGURATION_SOURCE: Current branch | Branch: ${currentBranch} | Type: source`);
+        logger.info(`BRANCH_CONFIGURATION_TARGET: Target branch for publish | Branch: ${targetBranch} | Type: destination`);
         // Look at target branch config to show version strategy
         const targetBranchConfig = runConfig.branches[targetBranch];
         if (targetBranchConfig === null || targetBranchConfig === void 0 ? void 0 : targetBranchConfig.version) {
             const versionType = targetBranchConfig.version.type;
             const versionTag = targetBranchConfig.version.tag;
             const versionIncrement = targetBranchConfig.version.increment;
-            logger.info(`   Target branch version strategy: ${versionType}${versionTag ? ` (tag: ${versionTag})` : ''}${versionIncrement ? ' with increment' : ''}`);
+            logger.info(`VERSION_STRATEGY: Target branch version configuration | Branch: ${targetBranch} | Type: ${versionType} | Tag: ${versionTag || 'none'} | Increment: ${versionIncrement ? 'enabled' : 'disabled'}`);
         }
     } else {
-        logger.debug(`No branch-specific targeting configured for '${currentBranch}', using default target: ${targetBranch}`);
+        logger.debug(`BRANCH_TARGETING_DEFAULT: No branch-specific configuration found | Branch: ${currentBranch} | Action: Using default target | Target: ${targetBranch}`);
     }
     // Handle --sync-target flag
     if ((_runConfig_publish1 = runConfig.publish) === null || _runConfig_publish1 === void 0 ? void 0 : _runConfig_publish1.syncTarget) {
@@ -486,13 +488,13 @@ const execute = async (runConfig)=>{
         return; // Exit after sync operation
     }
     // Check if target branch exists and create it if needed
-    logger.info(`Checking if target branch '${targetBranch}' exists...`);
+    logger.info(`TARGET_BRANCH_CHECK: Verifying target branch existence | Branch: ${targetBranch} | Action: Create if missing | Source: Current HEAD`);
     if (isDryRun) {
-        logger.info(`Would check if target branch '${targetBranch}' exists and create if needed`);
+        logger.info(`TARGET_BRANCH_CHECK: Would verify target branch exists and create if needed | Mode: dry-run | Branch: ${targetBranch}`);
     } else {
         const targetBranchExists = await localBranchExists(targetBranch);
         if (!targetBranchExists) {
-            logger.info(`🌟 Target branch '${targetBranch}' does not exist, creating it from current branch...`);
+            logger.info(`TARGET_BRANCH_CREATING: Target branch does not exist, creating from current branch | Branch: ${targetBranch} | Source: HEAD | Remote: origin`);
             try {
                 // Wrap git branch and push operations with lock
                 await runGitWithLock(process.cwd(), async ()=>{
@@ -502,73 +504,90 @@ const execute = async (runConfig)=>{
                         targetBranch,
                         'HEAD'
                     ]);
-                    logger.info(`✅ Created target branch: ${targetBranch}`);
+                    logger.info(`TARGET_BRANCH_CREATED: Successfully created target branch locally | Branch: ${targetBranch} | Source: HEAD`);
                     // Push the new branch to origin
                     await runSecure('git', [
                         'push',
                         'origin',
                         targetBranch
                     ]);
-                    logger.info(`✅ Pushed new target branch to origin: ${targetBranch}`);
+                    logger.info(`TARGET_BRANCH_PUSHED: Successfully pushed new target branch to remote | Branch: ${targetBranch} | Remote: origin/${targetBranch}`);
                 }, `create and push target branch ${targetBranch}`);
             } catch (error) {
                 throw new Error(`Failed to create target branch '${targetBranch}': ${error.message}`);
             }
         } else {
-            logger.info(`✅ Target branch '${targetBranch}' already exists`);
+            logger.info(`TARGET_BRANCH_EXISTS: Target branch already exists locally | Branch: ${targetBranch} | Status: ready`);
         }
     }
     // Run prechecks before starting any work
     await runPrechecks(runConfig, targetBranch);
     // Early check: determine if a release is necessary compared to target branch
-    logger.info('Evaluating if a release is necessary compared to target branch...');
+    logger.info('RELEASE_NECESSITY_CHECK: Evaluating if release is required | Comparison: current branch vs target | Target: ' + targetBranch + ' | Purpose: Avoid unnecessary publishes');
     try {
         const necessity = await isReleaseNecessaryComparedToTarget(targetBranch, isDryRun);
         if (!necessity.necessary) {
-            logger.info(`Skipping publish: ${necessity.reason}.`);
+            logger.info(`\nRELEASE_SKIPPED: No meaningful changes detected, skipping publish | Reason: ${necessity.reason} | Target: ${targetBranch}`);
             // Emit a machine-readable marker so tree mode can detect skip and avoid propagating versions
-            logger.info('KODRDRIV_PUBLISH_SKIPPED');
+            // CRITICAL: Use console.log to write to stdout (logger.info goes to stderr via winston)
+            // eslint-disable-next-line no-console
+            console.log('KODRDRIV_PUBLISH_SKIPPED');
             return;
         } else {
-            logger.verbose(`Proceeding with publish: ${necessity.reason}.`);
+            logger.verbose(`RELEASE_PROCEEDING: Meaningful changes detected, continuing with publish | Reason: ${necessity.reason} | Target: ${targetBranch}`);
         }
     } catch (error) {
         // On unexpected errors, proceed with publish to avoid false negatives blocking releases
-        logger.verbose(`Release necessity check encountered an issue (${error.message}). Proceeding with publish.`);
+        logger.verbose(`RELEASE_NECESSITY_CHECK_ERROR: Unable to determine release necessity | Error: ${error.message} | Action: Proceeding conservatively with publish | Rationale: Avoid blocking valid releases`);
     }
-    logger.info('Starting release process...');
+    logger.info('RELEASE_PROCESS_STARTING: Initiating release workflow | Target: ' + targetBranch + ' | Phase: dependency updates and version management');
     let pr = null;
     if (isDryRun) {
-        logger.info('Would check for existing pull request');
-        logger.info('Assuming no existing PR found for demo purposes');
+        logger.info('PR_CHECK: Would check for existing pull request | Mode: dry-run | Action: Skip PR lookup');
+        logger.info('PR_ASSUMPTION: Assuming no existing PR found | Mode: dry-run | Purpose: Demo workflow');
     } else {
         const branchName = await GitHub.getCurrentBranchName();
         pr = await GitHub.findOpenPullRequestByHeadRef(branchName);
     }
     if (pr) {
-        logger.info(`Found existing pull request for branch: ${pr.html_url}`);
+        logger.info(`PR_FOUND: Existing pull request detected for current branch | URL: ${pr.html_url} | Status: open`);
     } else {
-        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10, _runConfig_publish11;
-        logger.info('No open pull request found, starting new release publishing process...');
+        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10, _runConfig_publish11, _runConfig_publish12;
+        logger.info('PR_NOT_FOUND: No open pull request exists for current branch | Action: Starting new release publishing process | Next: Prepare dependencies and version');
         // STEP 1: Prepare for release (update dependencies and run prepublish checks) with NO version bump yet
-        logger.verbose('Preparing for release: switching from workspace to remote dependencies.');
+        logger.verbose('RELEASE_PREP_STARTING: Preparing for release | Phase: dependency management | Action: Switch from workspace to remote dependencies | Version Bump: Not yet applied');
         // Clean up any npm link references before updating dependencies
-        logger.verbose('Checking for npm link references in package-lock.json...');
+        logger.verbose('NPM_LINK_CHECK: Scanning package-lock.json for npm link references | File: package-lock.json | Purpose: Remove development symlinks before publish');
         await cleanupNpmLinkReferences(isDryRun);
-        logger.verbose('Updating dependencies to latest versions from registry');
-        const updatePatterns = (_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.dependencyUpdatePatterns;
+        // Update inter-project dependencies if --update-deps flag is present
+        const updateDepsScope = (_runConfig_publish4 = runConfig.publish) === null || _runConfig_publish4 === void 0 ? void 0 : _runConfig_publish4.updateDeps;
+        if (updateDepsScope) {
+            logger.info(`INTER_PROJECT_DEPS_UPDATE: Updating inter-project dependencies | Scope: ${updateDepsScope} | Type: inter-project | Command: kodrdriv updates`);
+            const Updates = await import('./updates.js');
+            const updatesConfig = {
+                ...runConfig,
+                dryRun: isDryRun,
+                updates: {
+                    scope: updateDepsScope,
+                    interProject: true
+                }
+            };
+            await Updates.execute(updatesConfig);
+        }
+        logger.verbose('DEPS_UPDATE_REGISTRY: Updating dependencies to latest versions from npm registry | Source: registry | Target: package.json');
+        const updatePatterns = (_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.dependencyUpdatePatterns;
         if (updatePatterns && updatePatterns.length > 0) {
-            logger.verbose(`Updating dependencies matching patterns: ${updatePatterns.join(', ')}`);
+            logger.verbose(`DEPS_UPDATE_PATTERNS: Updating dependencies matching specified patterns | Patterns: ${updatePatterns.join(', ')} | Count: ${updatePatterns.length} | Command: npm update`);
             const patternsArg = updatePatterns.join(' ');
             await runWithDryRunSupport(`npm update ${patternsArg}`, isDryRun);
         } else {
-            logger.verbose('No dependency update patterns specified, updating all dependencies');
+            logger.verbose('DEPS_UPDATE_ALL: No dependency patterns specified, updating all dependencies | Scope: all | Command: npm update');
             await runWithDryRunSupport('npm update', isDryRun);
         }
-        logger.info('Running prepublishOnly script...');
+        logger.info('PREPUBLISH_SCRIPT_RUNNING: Executing prepublishOnly script | Script: prepublishOnly | Purpose: Run pre-flight checks (clean, lint, build, test)');
         await runWithDryRunSupport('npm run prepublishOnly', isDryRun, {}, true); // Use inherited stdio
         // STEP 2: Commit dependency updates if any (still no version bump)
-        logger.verbose('Staging dependency updates for commit');
+        logger.verbose('DEPS_STAGING: Staging dependency updates for commit | Files: package.json + package-lock.json | Command: git add | Note: Version bump not yet applied');
         // Check if package-lock.json exists before trying to stage it
         const packageLockExists = await storage.exists('package-lock.json');
         const filesToStage = packageLockExists ? 'package.json package-lock.json' : 'package.json';
@@ -576,26 +595,26 @@ const execute = async (runConfig)=>{
         await runGitWithLock(process.cwd(), async ()=>{
             await runWithDryRunSupport(`git add ${filesToStage}`, isDryRun);
         }, 'stage dependency updates');
-        logger.verbose('Checking for staged dependency updates...');
+        logger.verbose('DEPS_COMMIT_CHECK: Checking for staged dependency updates | Command: git status | Purpose: Determine if commit needed');
         if (isDryRun) {
-            logger.verbose('Would create dependency update commit if changes are staged');
+            logger.verbose('DEPS_COMMIT_DRY_RUN: Would create dependency update commit if changes are staged | Mode: dry-run');
         } else {
             if (await hasStagedChanges()) {
-                logger.verbose('Staged dependency changes found, creating commit...');
+                logger.verbose('DEPS_COMMIT_CREATING: Staged dependency changes detected, creating commit | Files: ' + filesToStage + ' | Action: Execute commit command');
                 // Commit also needs git lock
                 await runGitWithLock(process.cwd(), async ()=>{
                     await execute$2(runConfig);
                 }, 'commit dependency updates');
             } else {
-                logger.verbose('No dependency changes to commit, skipping commit.');
+                logger.verbose('DEPS_COMMIT_SKIPPED: No dependency changes to commit | Files: ' + filesToStage + ' | Action: Skipping commit step');
             }
         }
         // STEP 3: Merge target branch into working branch (optional - now skipped by default since post-publish sync keeps branches in sync)
-        const skipPreMerge = ((_runConfig_publish5 = runConfig.publish) === null || _runConfig_publish5 === void 0 ? void 0 : _runConfig_publish5.skipPrePublishMerge) !== false; // Default to true (skip)
+        const skipPreMerge = ((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.skipPrePublishMerge) !== false; // Default to true (skip)
         if (skipPreMerge) {
-            logger.verbose(`⏭️  Skipping pre-publish merge (post-publish sync will handle branch synchronization)`);
+            logger.verbose(`PRE_MERGE_SKIPPED: Skipping pre-publish merge of target branch | Reason: Post-publish sync handles branch synchronization | Target: ${targetBranch} | Config: skipPrePublishMerge=true`);
         } else {
-            logger.info(`Merging target branch '${targetBranch}' into current branch to avoid version conflicts...`);
+            logger.info(`PRE_MERGE_STARTING: Merging target branch into current branch | Target: ${targetBranch} | Purpose: Avoid version conflicts | Phase: pre-publish`);
             if (isDryRun) {
                 logger.info(`Would merge ${targetBranch} into current branch`);
             } else {
@@ -604,23 +623,23 @@ const execute = async (runConfig)=>{
                     // Fetch the latest target branch
                     try {
                         await run(`git fetch origin ${targetBranch}:${targetBranch}`);
-                        logger.info(`✅ Fetched latest ${targetBranch}`);
+                        logger.info(`TARGET_BRANCH_FETCHED: Successfully fetched latest target branch | Branch: ${targetBranch} | Remote: origin/${targetBranch} | Purpose: Pre-merge sync`);
                     } catch (fetchError) {
-                        logger.warn(`⚠️ Could not fetch ${targetBranch}: ${fetchError.message}`);
-                        logger.warn('Continuing without merge - PR may have conflicts...');
+                        logger.warn(`TARGET_BRANCH_FETCH_FAILED: Unable to fetch target branch | Branch: ${targetBranch} | Error: ${fetchError.message} | Impact: Proceeding without merge, PR may have conflicts`);
+                        logger.warn('MERGE_SKIPPED_NO_FETCH: Continuing without pre-merge | Reason: Target branch fetch failed | Impact: PR may require manual conflict resolution');
                     }
                     // Check if merge is needed (avoid unnecessary merge commits)
                     try {
                         const { stdout: mergeBase } = await run(`git merge-base HEAD ${targetBranch}`);
                         const { stdout: targetCommit } = await run(`git rev-parse ${targetBranch}`);
                         if (mergeBase.trim() === targetCommit.trim()) {
-                            logger.info(`ℹ️  Already up-to-date with ${targetBranch}, no merge needed`);
+                            logger.info(`MERGE_NOT_NEEDED: Current branch already up-to-date with target | Branch: ${targetBranch} | Status: in-sync | Action: Skipping merge`);
                         } else {
                             // Try to merge target branch into current branch
                             let mergeSucceeded = false;
                             try {
                                 await run(`git merge ${targetBranch} --no-edit -m "Merge ${targetBranch} to sync before version bump"`);
-                                logger.info(`✅ Merged ${targetBranch} into current branch`);
+                                logger.info(`MERGE_SUCCESS: Successfully merged target branch into current branch | Target: ${targetBranch} | Purpose: Sync before version bump`);
                                 mergeSucceeded = true;
                             } catch (mergeError) {
                                 // If merge conflicts occur, check if they're only in version-related files
@@ -630,11 +649,11 @@ const execute = async (runConfig)=>{
                                     mergeError.stderr || ''
                                 ].join(' ');
                                 if (errorText.includes('CONFLICT')) {
-                                    logger.warn(`⚠️  Merge conflicts detected, attempting automatic resolution...`);
+                                    logger.warn(`MERGE_CONFLICTS_DETECTED: Merge conflicts found, attempting automatic resolution | Target: ${targetBranch} | Strategy: Auto-resolve version files`);
                                     // Get list of conflicted files
                                     const { stdout: conflictedFiles } = await run('git diff --name-only --diff-filter=U');
                                     const conflicts = conflictedFiles.trim().split('\n').filter(Boolean);
-                                    logger.verbose(`Conflicted files: ${conflicts.join(', ')}`);
+                                    logger.verbose(`MERGE_CONFLICTS_LIST: Conflicted files detected | Files: ${conflicts.join(', ')} | Count: ${conflicts.length}`);
                                     // Check if conflicts are only in package.json and package-lock.json
                                     const versionFiles = [
                                         'package.json',
@@ -642,29 +661,29 @@ const execute = async (runConfig)=>{
                                     ];
                                     const nonVersionConflicts = conflicts.filter((f)=>!versionFiles.includes(f));
                                     if (nonVersionConflicts.length > 0) {
-                                        logger.error(`❌ Cannot auto-resolve: conflicts in non-version files: ${nonVersionConflicts.join(', ')}`);
+                                        logger.error(`MERGE_AUTO_RESOLVE_FAILED: Cannot auto-resolve conflicts in non-version files | Files: ${nonVersionConflicts.join(', ')} | Count: ${nonVersionConflicts.length} | Resolution: Manual intervention required`);
                                         logger.error('');
-                                        logger.error('Please resolve conflicts manually:');
-                                        logger.error('   1. Resolve conflicts in the files listed above');
-                                        logger.error('   2. git add <resolved-files>');
-                                        logger.error('   3. git commit');
-                                        logger.error('   4. kodrdriv publish (to continue)');
+                                        logger.error('CONFLICT_RESOLUTION_REQUIRED: Manual steps to resolve conflicts:');
+                                        logger.error('   Step 1: Resolve conflicts in the files listed above');
+                                        logger.error('   Step 2: Stage resolved files | Command: git add <resolved-files>');
+                                        logger.error('   Step 3: Complete merge commit | Command: git commit');
+                                        logger.error('   Step 4: Resume publish process | Command: kodrdriv publish');
                                         logger.error('');
                                         throw new Error(`Merge conflicts in non-version files. Please resolve manually.`);
                                     }
                                     // Auto-resolve version conflicts by accepting current branch versions
                                     // (keep our working branch's version, which is likely already updated)
-                                    logger.info(`Auto-resolving version conflicts by keeping current branch versions...`);
+                                    logger.info(`MERGE_AUTO_RESOLVING: Automatically resolving version conflicts | Strategy: Keep current branch versions | Files: ${versionFiles.join(', ')}`);
                                     for (const file of conflicts){
                                         if (versionFiles.includes(file)) {
                                             await run(`git checkout --ours ${file}`);
                                             await run(`git add ${file}`);
-                                            logger.verbose(`Resolved ${file} using current branch version`);
+                                            logger.verbose(`MERGE_FILE_RESOLVED: Resolved file using current branch version | File: ${file} | Strategy: checkout --ours`);
                                         }
                                     }
                                     // Complete the merge
                                     await run(`git commit --no-edit -m "Merge ${targetBranch} to sync before version bump (auto-resolved version conflicts)"`);
-                                    logger.info(`✅ Auto-resolved version conflicts and completed merge`);
+                                    logger.info(`MERGE_AUTO_RESOLVE_SUCCESS: Successfully auto-resolved version conflicts and completed merge | Target: ${targetBranch} | Files: ${versionFiles.join(', ')}`);
                                     mergeSucceeded = true;
                                 } else {
                                     // Not a conflict error, re-throw
@@ -674,19 +693,19 @@ const execute = async (runConfig)=>{
                             // Only run npm install if merge actually happened
                             if (mergeSucceeded) {
                                 // Run npm install to update package-lock.json based on merged package.json
-                                logger.info('Running npm install after merge...');
+                                logger.info('POST_MERGE_NPM_INSTALL: Running npm install after merge | Purpose: Update package-lock.json based on merged package.json | Command: npm install');
                                 await run('npm install');
-                                logger.info('✅ npm install completed');
+                                logger.info('POST_MERGE_NPM_COMPLETE: npm install completed successfully | Status: Dependencies synchronized');
                                 // Commit any changes from npm install (e.g., package-lock.json updates)
                                 const { stdout: mergeChangesStatus } = await run('git status --porcelain');
                                 if (mergeChangesStatus.trim()) {
-                                    logger.verbose('Staging post-merge changes for commit');
+                                    logger.verbose('POST_MERGE_CHANGES_DETECTED: Changes detected after npm install | Action: Staging for commit | Command: git add');
                                     // Check if package-lock.json exists before trying to stage it
                                     const packageLockExistsPostMerge = await storage.exists('package-lock.json');
                                     const filesToStagePostMerge = packageLockExistsPostMerge ? 'package.json package-lock.json' : 'package.json';
                                     await run(`git add ${filesToStagePostMerge}`);
                                     if (await hasStagedChanges()) {
-                                        logger.verbose('Committing post-merge changes...');
+                                        logger.verbose('POST_MERGE_COMMIT: Committing post-merge changes | Files: ' + filesToStagePostMerge + ' | Purpose: Finalize merge');
                                         await execute$2(runConfig);
                                     }
                                 }
@@ -694,7 +713,7 @@ const execute = async (runConfig)=>{
                         }
                     } catch (error) {
                         // Only catch truly unexpected errors here
-                        logger.error(`❌ Unexpected error during merge: ${error.message}`);
+                        logger.error(`MERGE_UNEXPECTED_ERROR: Unexpected error during merge process | Error: ${error.message} | Target: ${targetBranch} | Action: Aborting publish`);
                         throw error;
                     }
                 }, `merge ${targetBranch} into current branch`);
@@ -707,7 +726,7 @@ const execute = async (runConfig)=>{
             logger.info('Would determine target version and update package.json');
             newVersion = '1.0.0'; // Mock version for dry run
         } else {
-            var _runConfig_publish12;
+            var _runConfig_publish13;
             const packageJsonContents = await storage.readFile('package.json', 'utf-8');
             const parsed = safeJsonParse(packageJsonContents, 'package.json');
             const packageJson = validatePackageJson(parsed, 'package.json');
@@ -719,28 +738,110 @@ const execute = async (runConfig)=>{
                 const branchDependentResult = await calculateBranchDependentVersion(currentVersion, currentBranch, runConfig.branches, targetBranch);
                 proposedVersion = branchDependentResult.version;
                 finalTargetBranch = branchDependentResult.targetBranch;
-                logger.info(`🎯 Branch-dependent version calculated: ${currentVersion} → ${proposedVersion}`);
-                logger.info(`🎯 Final target branch: ${finalTargetBranch}`);
+                logger.info(`VERSION_BRANCH_DEPENDENT_CALCULATED: Branch-dependent version calculated | Current: ${currentVersion} | Proposed: ${proposedVersion} | Strategy: branch-dependent`);
+                logger.info(`TARGET_BRANCH_FINAL: Final target branch determined | Branch: ${finalTargetBranch} | Source: branch-dependent config`);
                 // Update targetBranch for the rest of the function
                 targetBranch = finalTargetBranch;
             } else {
-                var _runConfig_publish13;
+                var _runConfig_publish14;
                 // Use existing logic for backward compatibility
-                const targetVersionInput = ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.targetVersion) || 'patch';
+                const targetVersionInput = ((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.targetVersion) || 'patch';
                 proposedVersion = calculateTargetVersion(currentVersion, targetVersionInput);
             }
             const targetTagName = `v${proposedVersion}`;
             const tagExists = await checkIfTagExists(targetTagName);
+            // Smart tag conflict handling
             if (tagExists) {
-                throw new Error(`Tag ${targetTagName} already exists. Please choose a different version or delete the existing tag.`);
+                const { getNpmPublishedVersion, getTagInfo } = await import('../util/general.js');
+                logger.warn(`TAG_ALREADY_EXISTS: Tag already exists in repository | Tag: ${targetTagName} | Status: conflict | Action: Check npm registry`);
+                // Check if this version is published on npm
+                const npmVersion = await getNpmPublishedVersion(packageJson.name);
+                const tagInfo = await getTagInfo(targetTagName);
+                if (npmVersion === proposedVersion) {
+                    var _runConfig_publish15;
+                    // Version is already published on npm
+                    logger.info(`VERSION_ALREADY_PUBLISHED: Version already published on npm registry | Version: ${proposedVersion} | Status: published | Action: Skipping`);
+                    logger.info(`PUBLISH_SKIPPED_DUPLICATE: Skipping publish operation | Reason: Package already at target version | Version: ${proposedVersion}`);
+                    logger.info('');
+                    logger.info('REPUBLISH_OPTIONS: Options if you need to republish:');
+                    logger.info(`   Option 1: Bump version | Command: npm version patch (or minor/major)`);
+                    logger.info(`   Option 2: Re-run publish | Command: kodrdriv publish`);
+                    logger.info('');
+                    if ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.skipAlreadyPublished) {
+                        logger.info('PUBLISH_SKIPPED_FLAG: Skipping package due to flag | Flag: --skip-already-published | Version: ' + proposedVersion + ' | Status: skipped');
+                        // Emit skip marker for tree mode detection
+                        // eslint-disable-next-line no-console
+                        console.log('KODRDRIV_PUBLISH_SKIPPED');
+                        return; // Exit without error
+                    } else {
+                        throw new Error(`Version ${proposedVersion} already published. Use --skip-already-published to continue.`);
+                    }
+                } else {
+                    var _tagInfo_commit, _runConfig_publish16;
+                    // Tag exists but version not on npm - likely failed previous publish
+                    logger.warn('');
+                    logger.warn('PUBLISH_SITUATION_ANALYSIS: Analyzing publish conflict situation | Tag: ' + targetTagName + ' | npm: ' + (npmVersion || 'not published'));
+                    logger.warn(`PUBLISH_ANALYSIS_TAG_EXISTS: Tag exists locally | Tag: ${targetTagName} | Commit: ${tagInfo === null || tagInfo === void 0 ? void 0 : (_tagInfo_commit = tagInfo.commit) === null || _tagInfo_commit === void 0 ? void 0 : _tagInfo_commit.substring(0, 8)}`);
+                    logger.warn(`PUBLISH_ANALYSIS_NPM_STATUS: npm registry status | Version: ${npmVersion || 'not published'} | Status: ${npmVersion ? 'published' : 'missing'}`);
+                    logger.warn(`PUBLISH_ANALYSIS_CONCLUSION: Previous publish likely failed after tag creation | Reason: Tag exists but not on npm | Resolution: Recovery needed`);
+                    logger.warn('');
+                    logger.warn('PUBLISH_RECOVERY_OPTIONS: Recovery options available:');
+                    logger.warn('   OPTION_1_FORCE: Force republish by deleting tag | Command: kodrdriv publish --force-republish');
+                    logger.warn('   OPTION_2_BUMP: Skip version and bump | Command: npm version patch && kodrdriv publish');
+                    logger.warn('   OPTION_3_MANUAL: Manually delete tag:');
+                    logger.warn(`      Command: git tag -d ${targetTagName}`);
+                    logger.warn(`      Command: git push origin :refs/tags/${targetTagName}`);
+                    logger.warn('');
+                    if ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.forceRepublish) {
+                        logger.info('PUBLISH_FORCE_REPUBLISH: Force republish mode enabled | Action: Deleting existing tag | Tag: ' + targetTagName + ' | Purpose: Allow republish');
+                        if (!isDryRun) {
+                            const { runSecure } = await import('@eldrforge/git-tools');
+                            // Delete local tag
+                            try {
+                                await runSecure('git', [
+                                    'tag',
+                                    '-d',
+                                    targetTagName
+                                ]);
+                                logger.info(`TAG_DELETED_LOCAL: Deleted local tag | Tag: ${targetTagName} | Status: removed-local`);
+                            } catch (error) {
+                                logger.debug(`Could not delete local tag: ${error.message}`);
+                            }
+                            // Delete remote tag
+                            try {
+                                await runSecure('git', [
+                                    'push',
+                                    'origin',
+                                    `:refs/tags/${targetTagName}`
+                                ]);
+                                logger.info(`TAG_DELETED_REMOTE: Deleted remote tag | Tag: ${targetTagName} | Remote: origin | Status: removed-remote`);
+                            } catch (error) {
+                                logger.debug(`Could not delete remote tag: ${error.message}`);
+                            }
+                            logger.info('PUBLISH_TAG_CLEANUP_COMPLETE: Tag deleted successfully | Status: ready-for-publish | Next: Continue with publish workflow');
+                        } else {
+                            logger.info('Would delete tags and continue with publish');
+                        }
+                    } else {
+                        throw new Error(`Tag ${targetTagName} already exists. Use --force-republish to override.`);
+                    }
+                }
             }
-            if ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.interactive) {
-                var _runConfig_publish14;
-                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, (_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.targetVersion);
+            if ((_runConfig_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.interactive) {
+                var _runConfig_publish17;
+                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, (_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.targetVersion);
                 const confirmedTagName = `v${newVersion}`;
                 const confirmedTagExists = await checkIfTagExists(confirmedTagName);
                 if (confirmedTagExists) {
-                    throw new Error(`Tag ${confirmedTagName} already exists. Please choose a different version or delete the existing tag.`);
+                    var _runConfig_publish18;
+                    const { getNpmPublishedVersion } = await import('../util/general.js');
+                    const npmVersion = await getNpmPublishedVersion(packageJson.name);
+                    if (npmVersion === newVersion) {
+                        throw new Error(`Tag ${confirmedTagName} already exists and version is published on npm. Please choose a different version.`);
+                    } else if (!((_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.forceRepublish)) {
+                        throw new Error(`Tag ${confirmedTagName} already exists. Use --force-republish to override.`);
+                    }
+                // If forceRepublish is set, we'll continue (tag will be deleted later)
                 }
             } else {
                 newVersion = proposedVersion;
@@ -781,23 +882,23 @@ const execute = async (runConfig)=>{
         releaseConfig.release = {
             ...runConfig.release,
             currentBranch: currentBranch,
-            ...((_runConfig_publish6 = runConfig.publish) === null || _runConfig_publish6 === void 0 ? void 0 : _runConfig_publish6.from) && {
+            ...((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.from) && {
                 from: runConfig.publish.from
             },
-            ...((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.interactive) && {
+            ...((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.interactive) && {
                 interactive: runConfig.publish.interactive
             },
-            ...((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.fromMain) && {
+            ...((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.fromMain) && {
                 fromMain: runConfig.publish.fromMain
             }
         };
-        if ((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.from) {
+        if ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.from) {
             logger.verbose(`Using custom 'from' reference for release notes: ${runConfig.publish.from}`);
         }
-        if ((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.interactive) {
+        if ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.interactive) {
             logger.verbose('Interactive mode enabled for release notes generation');
         }
-        if ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.fromMain) {
+        if ((_runConfig_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.fromMain) {
             logger.verbose('Forcing comparison against main branch for release notes');
         }
         const releaseSummary = await execute$1(releaseConfig);
@@ -855,12 +956,12 @@ const execute = async (runConfig)=>{
             logger.debug(`Could not verify workflow configuration for wait skip: ${error.message}`);
         }
         if (!shouldSkipWait) {
-            var _runConfig_publish15, _runConfig_publish16, _runConfig_publish17;
+            var _runConfig_publish19, _runConfig_publish20, _runConfig_publish21;
             // Configure timeout and user confirmation behavior
-            const timeout = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
-            const senditMode = ((_runConfig_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.sendit) || false;
+            const timeout = ((_runConfig_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
+            const senditMode = ((_runConfig_publish20 = runConfig.publish) === null || _runConfig_publish20 === void 0 ? void 0 : _runConfig_publish20.sendit) || false;
             // sendit flag overrides skipUserConfirmation - if sendit is true, skip confirmation
-            const skipUserConfirmation = senditMode || ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.skipUserConfirmation) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish21 = runConfig.publish) === null || _runConfig_publish21 === void 0 ? void 0 : _runConfig_publish21.skipUserConfirmation) || false;
             await GitHub.waitForPullRequestChecks(pr.number, {
                 timeout,
                 skipUserConfirmation
@@ -876,14 +977,14 @@ const execute = async (runConfig)=>{
         } catch (error) {
             // Check if this is a merge conflict error
             if (error.message && (error.message.includes('not mergeable') || error.message.includes('Pull Request is not mergeable') || error.message.includes('merge conflict'))) {
-                logger.error(`❌ Pull Request #${pr.number} has merge conflicts that need to be resolved.`);
+                logger.error(`PR_MERGE_CONFLICTS: Pull request has merge conflicts | PR Number: ${pr.number} | Status: conflicts | Resolution: Manual intervention required`);
                 logger.error('');
-                logger.error('📋 To resolve this issue:');
-                logger.error(`   1. Visit the Pull Request: ${pr.html_url}`);
-                logger.error('   2. Resolve the merge conflicts through GitHub\'s web interface or locally');
-                logger.error('   3. Once conflicts are resolved, re-run the publish command');
+                logger.error('PR_CONFLICT_RESOLUTION: Steps to resolve conflicts:');
+                logger.error(`   Step 1: Visit pull request | URL: ${pr.html_url}`);
+                logger.error('   Step 2: Resolve merge conflicts | Method: GitHub UI or local');
+                logger.error('   Step 3: Re-run publish command | Command: kodrdriv publish');
                 logger.error('');
-                logger.error('💡 The command will automatically detect the existing PR and continue from where it left off.');
+                logger.error('PR_AUTO_CONTINUE: Command will auto-detect existing PR | Behavior: Continues from where it left off | No re-creation needed');
                 throw new Error(`Merge conflicts detected in PR #${pr.number}. Please resolve conflicts and re-run the command.`);
             } else {
                 // Re-throw other merge errors
@@ -901,7 +1002,7 @@ const execute = async (runConfig)=>{
             '--porcelain'
         ]);
         if (statusOutput.trim()) {
-            logger.info('📦 Stashing uncommitted changes before checkout...');
+            logger.info('PUBLISH_STASH_SAVING: Stashing uncommitted changes before checkout | Command: git stash push | Purpose: Protect changes during branch switch');
             await runSecure('git', [
                 'stash',
                 'push',
@@ -909,7 +1010,7 @@ const execute = async (runConfig)=>{
                 'kodrdriv: stash before checkout target branch'
             ]);
             hasStashedChanges = true;
-            logger.info('✅ Successfully stashed uncommitted changes');
+            logger.info('PUBLISH_STASH_SUCCESS: Successfully stashed uncommitted changes | Status: saved | Name: kodrdriv stash');
         }
     }
     try {
@@ -919,31 +1020,32 @@ const execute = async (runConfig)=>{
         }, `checkout ${targetBranch}`);
         // Sync target branch with remote to avoid conflicts during PR creation
         if (!isDryRun) {
-            logger.info(`🔄 Syncing ${targetBranch} with remote to avoid PR conflicts...`);
+            logger.info(`PUBLISH_TARGET_SYNCING: Syncing target branch with remote | Branch: ${targetBranch} | Remote: origin | Purpose: Avoid PR conflicts`);
             try {
                 const remoteExists = await run(`git ls-remote --exit-code --heads origin ${targetBranch}`).then(()=>true).catch(()=>false);
                 if (remoteExists) {
                     await runGitWithLock(process.cwd(), async ()=>{
-                        await run(`git pull origin ${targetBranch} --no-edit`);
-                    }, `pull ${targetBranch}`);
-                    logger.info(`✅ Synced ${targetBranch} with remote`);
+                        await run(`git fetch origin ${targetBranch}`);
+                        await run(`git merge origin/${targetBranch} --no-ff --no-edit`);
+                    }, `sync ${targetBranch}`);
+                    logger.info(`PUBLISH_TARGET_SYNCED: Successfully synced target with remote | Branch: ${targetBranch} | Remote: origin | Status: in-sync`);
                 } else {
-                    logger.info(`ℹ️ No remote ${targetBranch} branch found, will be created on first push`);
+                    logger.info(`PUBLISH_TARGET_NO_REMOTE: No remote target branch found | Branch: ${targetBranch} | Remote: origin | Action: Will be created on first push`);
                 }
             } catch (syncError) {
                 if (syncError.message && syncError.message.includes('CONFLICT')) {
-                    logger.error(`❌ Merge conflicts detected when syncing ${targetBranch} with remote`);
-                    logger.error(`   Please resolve the conflicts manually:`);
-                    logger.error(`   1. git checkout ${targetBranch}`);
-                    logger.error(`   2. git pull origin ${targetBranch}`);
-                    logger.error(`   3. Resolve conflicts in the files`);
-                    logger.error(`   4. git add <resolved-files>`);
-                    logger.error(`   5. git commit`);
-                    logger.error(`   6. git checkout ${currentBranch}`);
-                    logger.error(`   7. kodrdriv publish (to continue)`);
+                    logger.error(`PUBLISH_SYNC_CONFLICTS: Merge conflicts during target sync | Branch: ${targetBranch} | Remote: origin | Status: conflicts-detected`);
+                    logger.error(`PUBLISH_SYNC_RESOLUTION: Manual conflict resolution steps:`);
+                    logger.error(`   Step 1: Checkout target | Command: git checkout ${targetBranch}`);
+                    logger.error(`   Step 2: Pull and merge | Command: git pull origin ${targetBranch}`);
+                    logger.error(`   Step 3: Resolve conflicts in files`);
+                    logger.error(`   Step 4: Stage resolved files | Command: git add <resolved-files>`);
+                    logger.error(`   Step 5: Complete merge | Command: git commit`);
+                    logger.error(`   Step 6: Return to branch | Command: git checkout ${currentBranch}`);
+                    logger.error(`   Step 7: Resume publish | Command: kodrdriv publish`);
                     throw syncError;
                 } else {
-                    logger.warn(`⚠️ Could not sync ${targetBranch} with remote: ${syncError.message}`);
+                    logger.warn(`PUBLISH_SYNC_WARNING: Could not sync target with remote | Branch: ${targetBranch} | Remote: origin | Error: ${syncError.message}`);
                 // Continue with publish process, but log the warning
                 }
             }
@@ -953,17 +1055,17 @@ const execute = async (runConfig)=>{
     } catch (error) {
         // Check if this is a merge conflict or sync issue
         if (!isDryRun && (error.message.includes('conflict') || error.message.includes('CONFLICT') || error.message.includes('diverged') || error.message.includes('non-fast-forward'))) {
-            logger.error(`❌ Failed to sync target branch '${targetBranch}' with remote.`);
+            logger.error(`PUBLISH_TARGET_SYNC_FAILED: Failed to sync target branch with remote | Branch: ${targetBranch} | Remote: origin | Impact: Cannot proceed safely`);
             logger.error('');
-            logger.error('📋 Recovery options:');
-            logger.error(`   1. Run 'kodrdriv publish --sync-target' to attempt automatic resolution`);
-            logger.error(`   2. Manually resolve conflicts:`);
-            logger.error(`      - git checkout ${targetBranch}`);
-            logger.error(`      - git pull origin ${targetBranch}`);
-            logger.error(`      - Resolve any conflicts and commit`);
-            logger.error(`      - Re-run your original publish command`);
+            logger.error('PUBLISH_SYNC_RECOVERY_OPTIONS: Available recovery options:');
+            logger.error(`   OPTION_1_AUTO: Attempt automatic resolution | Command: kodrdriv publish --sync-target`);
+            logger.error(`   OPTION_2_MANUAL: Manually resolve conflicts:`);
+            logger.error(`      Step 1: Checkout target | Command: git checkout ${targetBranch}`);
+            logger.error(`      Step 2: Pull from remote | Command: git pull origin ${targetBranch}`);
+            logger.error(`      Step 3: Resolve conflicts and commit`);
+            logger.error(`      Step 4: Re-run publish | Command: kodrdriv publish`);
             logger.error('');
-            logger.error('💡 The publish process has been stopped to prevent data loss.');
+            logger.error('PUBLISH_STOPPED_SAFETY: Publish process stopped | Reason: Prevent data loss | Status: safe-to-recover');
             throw new Error(`Target branch '${targetBranch}' sync failed. Use recovery options above to resolve.`);
         } else {
             // Re-throw other errors
@@ -972,16 +1074,16 @@ const execute = async (runConfig)=>{
     }
     // Restore stashed changes if we stashed them
     if (hasStashedChanges) {
-        logger.info('📦 Restoring previously stashed changes...');
+        logger.info('PUBLISH_STASH_RESTORING: Restoring previously stashed changes | Command: git stash pop | Purpose: Restore working directory state');
         try {
             await runSecure('git', [
                 'stash',
                 'pop'
             ]);
-            logger.info('✅ Successfully restored stashed changes');
+            logger.info('PUBLISH_STASH_RESTORED: Successfully restored stashed changes | Status: restored | Stash: removed');
         } catch (stashError) {
-            logger.warn(`⚠️  Warning: Could not restore stashed changes: ${stashError.message}`);
-            logger.warn('   Your changes are still available in the git stash. Run "git stash list" to see them.');
+            logger.warn(`PUBLISH_STASH_RESTORE_FAILED: Could not restore stashed changes | Error: ${stashError.message} | Impact: Changes still in stash`);
+            logger.warn('PUBLISH_STASH_AVAILABLE: Changes available in git stash | Command: git stash list | Purpose: View and restore manually');
         }
     }
     // Now create and push the tag on the target branch
@@ -1073,9 +1175,9 @@ const execute = async (runConfig)=>{
     }
     logger.info('Creating GitHub release...');
     if (isDryRun) {
-        var _runConfig_publish18;
+        var _runConfig_publish22;
         logger.info('Would read package.json version and create GitHub release with retry logic');
-        const milestonesEnabled = !((_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.noMilestones);
+        const milestonesEnabled = !((_runConfig_publish22 = runConfig.publish) === null || _runConfig_publish22 === void 0 ? void 0 : _runConfig_publish22.noMilestones);
         if (milestonesEnabled) {
             logger.info('Would close milestone for released version');
         } else {
@@ -1091,13 +1193,13 @@ const execute = async (runConfig)=>{
         let retries = 3;
         while(retries > 0){
             try {
-                var _runConfig_publish19;
+                var _runConfig_publish23;
                 await GitHub.createRelease(tagName, releaseTitle, releaseNotesContent);
                 logger.info(`GitHub release created successfully for tag: ${tagName}`);
                 // Close milestone for this version if enabled
-                const milestonesEnabled = !((_runConfig_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.noMilestones);
+                const milestonesEnabled = !((_runConfig_publish23 = runConfig.publish) === null || _runConfig_publish23 === void 0 ? void 0 : _runConfig_publish23.noMilestones);
                 if (milestonesEnabled) {
-                    logger.info('🏁 Closing milestone for released version...');
+                    logger.info('PUBLISH_MILESTONE_CLOSING: Closing milestone for released version | Action: Close GitHub milestone | Purpose: Mark release complete');
                     const version = tagName.replace(/^v/, ''); // Remove 'v' prefix if present
                     await GitHub.closeMilestoneForVersion(version);
                 } else {
@@ -1128,12 +1230,12 @@ const execute = async (runConfig)=>{
         if (isDryRun) {
             logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            var _runConfig_publish20, _runConfig_publish21, _runConfig_publish22, _runConfig_publish23;
-            const workflowTimeout = ((_runConfig_publish20 = runConfig.publish) === null || _runConfig_publish20 === void 0 ? void 0 : _runConfig_publish20.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
-            const senditMode = ((_runConfig_publish21 = runConfig.publish) === null || _runConfig_publish21 === void 0 ? void 0 : _runConfig_publish21.sendit) || false;
-            const skipUserConfirmation = senditMode || ((_runConfig_publish22 = runConfig.publish) === null || _runConfig_publish22 === void 0 ? void 0 : _runConfig_publish22.skipUserConfirmation) || false;
+            var _runConfig_publish24, _runConfig_publish25, _runConfig_publish26, _runConfig_publish27;
+            const workflowTimeout = ((_runConfig_publish24 = runConfig.publish) === null || _runConfig_publish24 === void 0 ? void 0 : _runConfig_publish24.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
+            const senditMode = ((_runConfig_publish25 = runConfig.publish) === null || _runConfig_publish25 === void 0 ? void 0 : _runConfig_publish25.sendit) || false;
+            const skipUserConfirmation = senditMode || ((_runConfig_publish26 = runConfig.publish) === null || _runConfig_publish26 === void 0 ? void 0 : _runConfig_publish26.skipUserConfirmation) || false;
             // Get workflow names - either from config or auto-detect
-            let workflowNames = (_runConfig_publish23 = runConfig.publish) === null || _runConfig_publish23 === void 0 ? void 0 : _runConfig_publish23.releaseWorkflowNames;
+            let workflowNames = (_runConfig_publish27 = runConfig.publish) === null || _runConfig_publish27 === void 0 ? void 0 : _runConfig_publish27.releaseWorkflowNames;
             if (!workflowNames || workflowNames.length === 0) {
                 logger.info('No specific workflow names configured, auto-detecting workflows triggered by release events...');
                 try {
@@ -1159,7 +1261,7 @@ const execute = async (runConfig)=>{
     }
     // Switch back to source branch and sync with target
     logger.info('');
-    logger.info(`🔄 Syncing source branch with target after publish...`);
+    logger.info(`PUBLISH_POST_SYNC: Syncing source branch with target after publish | Purpose: Keep branches synchronized | Strategy: Reset and force push`);
     await runWithDryRunSupport(`git checkout ${currentBranch}`, isDryRun);
     if (!isDryRun) {
         // Sync target into source
@@ -1169,10 +1271,32 @@ const execute = async (runConfig)=>{
             // The squash merge created a single commit on target that represents all source commits
             logger.info(`Resetting ${currentBranch} to ${targetBranch} (squash merge)...`);
             await run(`git reset --hard ${targetBranch}`);
-            logger.info(`✅ Reset ${currentBranch} to ${targetBranch}`);
+            logger.info(`PUBLISH_BRANCH_RESET: Reset source branch to target | Source: ${currentBranch} | Target: ${targetBranch} | Status: synchronized`);
+            // After squash merge and reset, we need to force push
+            // This is safe because we just merged to main and are syncing working branch
+            logger.info(`PUBLISH_FORCE_PUSHING: Force pushing synchronized branch | Branch: ${currentBranch} | Remote: origin | Purpose: Complete post-publish sync`);
+            try {
+                // Verify that remote working branch is ancestor of main (safety check)
+                try {
+                    await run(`git fetch origin ${currentBranch}`);
+                    await run(`git merge-base --is-ancestor origin/${currentBranch} ${targetBranch}`);
+                    logger.verbose(`✓ Safety check passed: origin/${currentBranch} is ancestor of ${targetBranch}`);
+                } catch  {
+                    // Remote branch might not exist yet, or already in sync - both OK
+                    logger.verbose(`Remote ${currentBranch} does not exist or is already synced`);
+                }
+                // Use --force-with-lease for safer force push
+                await run(`git push --force-with-lease origin ${currentBranch}`);
+                logger.info(`PUBLISH_FORCE_PUSH_SUCCESS: Successfully force pushed to remote | Branch: ${currentBranch} | Remote: origin | Status: synchronized`);
+            } catch (pushError) {
+                // If force push fails, provide helpful message
+                logger.warn(`PUBLISH_FORCE_PUSH_FAILED: Could not force push branch | Branch: ${currentBranch} | Remote: origin | Error: ${pushError.message}`);
+                logger.warn(`PUBLISH_MANUAL_PUSH_NEEDED: Manual force push required | Action: Push manually`);
+                logger.warn(`PUBLISH_MANUAL_PUSH_COMMAND: Force push command | Command: git push --force-with-lease origin ${currentBranch}`);
+            }
         } else {
             // For merge/rebase methods, try to merge target back into source
-            logger.info(`Merging ${targetBranch} into ${currentBranch}...`);
+            logger.info(`PUBLISH_MERGE_TARGET_BACK: Merging target back into source | Target: ${targetBranch} | Source: ${currentBranch} | Purpose: Sync branches after publish`);
             // Try fast-forward first (works with merge/rebase methods)
             // Use runSecure to avoid error output for expected failure
             let fastForwardSucceeded = false;
@@ -1183,13 +1307,13 @@ const execute = async (runConfig)=>{
                     '--ff-only'
                 ]);
                 fastForwardSucceeded = true;
-                logger.info(`✅ Fast-forward merged ${targetBranch} into ${currentBranch}`);
+                logger.info(`PUBLISH_MERGE_FF_SUCCESS: Fast-forward merged target into source | Target: ${targetBranch} | Source: ${currentBranch} | Status: merged`);
             } catch  {
                 logger.verbose(`Fast-forward merge not possible, performing regular merge...`);
             }
             if (!fastForwardSucceeded) {
                 await run(`git merge ${targetBranch} --no-edit`);
-                logger.info(`✅ Merged ${targetBranch} into ${currentBranch}`);
+                logger.info(`PUBLISH_MERGE_SUCCESS: Merged target into source | Target: ${targetBranch} | Source: ${currentBranch} | Status: merged`);
             }
         }
         // Determine version bump based on branch configuration
@@ -1208,36 +1332,32 @@ const execute = async (runConfig)=>{
             }
         }
         // Bump to next development version
-        logger.info(`Bumping to next development version...`);
+        logger.info(`PUBLISH_DEV_VERSION_BUMPING: Bumping to next development version | Command: ${versionCommand} | Tag: ${versionTag} | Purpose: Prepare for next cycle`);
         try {
             const { stdout: newVersion } = await run(`npm version ${versionCommand} --preid=${versionTag}`);
-            logger.info(`✅ Version bumped to: ${newVersion.trim()}`);
+            logger.info(`PUBLISH_DEV_VERSION_BUMPED: Version bumped successfully | New Version: ${newVersion.trim()} | Type: development | Status: completed`);
         } catch (versionError) {
-            logger.warn(`⚠️  Failed to bump version: ${versionError.message}`);
-            logger.warn('   You may need to manually bump the version for next development cycle.');
+            logger.warn(`PUBLISH_DEV_VERSION_BUMP_FAILED: Failed to bump version | Error: ${versionError.message} | Impact: Version not updated`);
+            logger.warn('PUBLISH_MANUAL_VERSION_BUMP: Manual version bump may be needed | Action: Bump manually for next cycle | Command: npm version');
         }
         // Push updated source branch
-        logger.info(`Pushing updated ${currentBranch} branch...`);
+        logger.info(`PUBLISH_PUSH_SOURCE: Pushing updated source branch | Branch: ${currentBranch} | Remote: origin | Purpose: Push development version`);
         try {
             await runGitWithLock(process.cwd(), async ()=>{
                 await run(`git push origin ${currentBranch}`);
             }, `push ${currentBranch}`);
-            logger.info(`✅ Pushed ${currentBranch} to origin`);
+            logger.info(`PUBLISH_PUSH_SOURCE_SUCCESS: Pushed source branch successfully | Branch: ${currentBranch} | Remote: origin | Status: pushed`);
         } catch (pushError) {
-            logger.warn(`⚠️  Failed to push ${currentBranch}: ${pushError.message}`);
-            logger.warn(`   Please push manually: git push origin ${currentBranch}`);
+            logger.warn(`PUBLISH_PUSH_SOURCE_FAILED: Failed to push source branch | Branch: ${currentBranch} | Error: ${pushError.message} | Impact: Need manual push`);
+            logger.warn(`PUBLISH_MANUAL_PUSH_COMMAND: Manual push command | Command: git push origin ${currentBranch}`);
         }
     } else {
-        if (mergeMethod === 'squash') {
-            logger.info(`Would reset ${currentBranch} to ${targetBranch} (squash merge)`);
-        } else {
-            logger.info(`Would merge ${targetBranch} into ${currentBranch} with --ff-only`);
-        }
-        logger.info(`Would bump version to next development version`);
-        logger.info(`Would push ${currentBranch} to origin`);
+        logger.info(`PUBLISH_MERGE_DRY_RUN: Would merge target into source | Mode: dry-run | Target: ${targetBranch} | Source: ${currentBranch} | Strategy: ff-only`);
+        logger.info(`PUBLISH_VERSION_DRY_RUN: Would bump version to next development | Mode: dry-run | Action: Version bump`);
+        logger.info(`PUBLISH_PUSH_DRY_RUN: Would push source to remote | Mode: dry-run | Branch: ${currentBranch} | Remote: origin`);
     }
     logger.info('');
-    logger.info(`✅ Publish complete - on ${currentBranch} with next development version`);
+    logger.info(`PUBLISH_COMPLETE: Publish workflow completed successfully | Branch: ${currentBranch} | Status: completed | Version: next-development`);
 };
 
 export { execute };