@grunnverk/commands-publish 1.5.7-dev.20260131223731.750cd33 → 1.5.7-dev.20260131231507.728276

package/dist/index.js

@@ -4,13 +4,13 @@ import { createStorage, calculateTargetVersion, incrementPatchVersion as increme
 import { scanForPackageJsonFiles } from '@grunnverk/tree-core';
 import * as GitHub from '@grunnverk/github-tools';
 import { getOctokit } from '@grunnverk/github-tools';
-import fs, { readFile } from 'fs/promises';
+import fs, { readFile, access } from 'fs/promises';
 import * as path from 'path';
 import path__default from 'path';
 import * as Commit from '@grunnverk/commands-git';
 import { Formatter } from '@kjerneverk/riotprompt';
 import 'dotenv/config';
-import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createReleasePrompt, runAgenticPublish, formatAgenticPublishResult } from '@grunnverk/ai-service';
+import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice, STANDARD_CHOICES, getLLMFeedbackInEditor, editContentInEditor, createCompletionWithRetry, createReleasePrompt } from '@grunnverk/ai-service';
 
 /**
  * Create retroactive working branch tags for past releases
@@ -537,6 +537,80 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
     'examples/',
     'test-*/'
 ];
+/**
+ * Checks if .gitignore contains required patterns to prevent publishing
+ * development artifacts and sensitive files.
+ */ async function checkGitignorePatterns$1(directory, checks) {
+    const logger = getLogger();
+    const gitignorePath = path.join(directory, '.gitignore');
+    // Required patterns that must be present in .gitignore
+    const requiredPatterns = [
+        'node_modules',
+        'dist',
+        'package-lock.json',
+        '.env',
+        'output/',
+        'coverage',
+        '.kodrdriv*'
+    ];
+    // Check if .gitignore exists
+    try {
+        await access(gitignorePath);
+    } catch  {
+        checks.gitignore.passed = false;
+        checks.gitignore.issues.push('.gitignore file not found');
+        checks.gitignore.issues.push(`Create .gitignore with patterns: ${requiredPatterns.join(', ')}`);
+        return;
+    }
+    // Read .gitignore content
+    let gitignoreContent;
+    try {
+        gitignoreContent = await readFile(gitignorePath, 'utf-8');
+    } catch (error) {
+        checks.gitignore.passed = false;
+        checks.gitignore.issues.push(`Failed to read .gitignore: ${error.message}`);
+        return;
+    }
+    // Parse .gitignore into lines, ignoring comments and empty lines
+    const gitignoreLines = gitignoreContent.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.startsWith('#'));
+    // Check for missing patterns
+    const missingPatterns = [];
+    for (const pattern of requiredPatterns){
+        // Check if the pattern exists in any of the gitignore lines
+        const found = gitignoreLines.some((line)=>{
+            // Exact match
+            if (line === pattern) return true;
+            // Pattern with wildcard - check if the pattern or any matching line exists
+            if (pattern.includes('*')) {
+                const basePattern = pattern.replace('*', '');
+                // Accept exact wildcard pattern, base pattern, or any line starting with base
+                return line === pattern || line === basePattern || line.startsWith(basePattern);
+            }
+            // Pattern with trailing slash - check both with and without slash
+            if (pattern.endsWith('/')) {
+                const basePattern = pattern.slice(0, -1);
+                return line === basePattern || line === pattern || line.startsWith(pattern);
+            }
+            // Line with trailing slash - check if it matches the pattern (e.g., "node_modules/" matches "node_modules")
+            if (line.endsWith('/')) {
+                const lineBase = line.slice(0, -1);
+                return lineBase === pattern || line.startsWith(pattern + '/');
+            }
+            return false;
+        });
+        if (!found) {
+            missingPatterns.push(pattern);
+        }
+    }
+    // Report missing patterns (relaxed check - allow variations)
+    const criticalMissing = missingPatterns.filter((p)=>!p.includes('coverage') && p !== 'package-lock.json');
+    if (criticalMissing.length > 0) {
+        checks.gitignore.passed = false;
+        checks.gitignore.issues.push(`Missing required patterns: ${criticalMissing.join(', ')}`);
+        checks.gitignore.issues.push('These patterns prevent committing build artifacts and sensitive files');
+    }
+    logger.debug(`Gitignore check: ${checks.gitignore.passed ? 'passed' : 'failed'}`);
+}
 /**
  * Execute check-development command
  */ async function execute$2(config) {
@@ -564,6 +638,10 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
     const isTree = packageJsonFiles.length > 1;
     logger.info(`Detected ${isTree ? 'tree' : 'single package'} with ${packageJsonFiles.length} package(s)`);
     const checks = {
+        gitignore: {
+            passed: true,
+            issues: []
+        },
         branch: {
             passed: true,
             issues: []
@@ -600,6 +678,8 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
     const packagesToCheck = isTree ? packageJsonFiles : [
         path.join(directory, 'package.json')
     ];
+    // Check .gitignore patterns (required for publish to succeed)
+    await checkGitignorePatterns$1(directory, checks);
     // Build a set of all local package names for link status checking
     const localPackageNames = new Set();
     for (const pkgJsonPath of packagesToCheck){
@@ -683,7 +763,7 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
                     // Ignore - there might not be a merge to abort if it was a fast-forward
                     }
                 } catch (mergeError) {
-                    var _mergeError_message, _mergeError_stderr;
+                    var _mergeError_message, _mergeError_stderr, _mergeError_stdout;
                     // Abort any partial merge
                     try {
                         await run('git merge --abort', {
@@ -694,7 +774,7 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
                     // Ignore abort errors
                     }
                     // If merge failed, there are likely conflicts
-                    if (((_mergeError_message = mergeError.message) === null || _mergeError_message === void 0 ? void 0 : _mergeError_message.includes('CONFLICT')) || ((_mergeError_stderr = mergeError.stderr) === null || _mergeError_stderr === void 0 ? void 0 : _mergeError_stderr.includes('CONFLICT'))) {
+                    if (((_mergeError_message = mergeError.message) === null || _mergeError_message === void 0 ? void 0 : _mergeError_message.includes('CONFLICT')) || ((_mergeError_stderr = mergeError.stderr) === null || _mergeError_stderr === void 0 ? void 0 : _mergeError_stderr.includes('CONFLICT')) || ((_mergeError_stdout = mergeError.stdout) === null || _mergeError_stdout === void 0 ? void 0 : _mergeError_stdout.includes('CONFLICT'))) {
                         checks.mergeConflicts.passed = false;
                         checks.mergeConflicts.issues.push(`${pkgName}: Merge conflicts detected with ${targetBranch} branch`);
                     } else {
@@ -841,7 +921,7 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
     // Build summary - linkStatus and releaseWorkflow are not included in allPassed (recommendations)
     // mergeConflicts is ALWAYS checked (critical for preventing post-merge failures)
     // openPRs is only checked when validateRelease is true
-    const allPassed = checks.branch.passed && checks.remoteSync.passed && checks.mergeConflicts.passed && checks.devVersion.passed && (validateRelease ? checks.openPRs.passed : true);
+    const allPassed = checks.gitignore.passed && checks.branch.passed && checks.remoteSync.passed && checks.mergeConflicts.passed && checks.devVersion.passed && (validateRelease ? checks.openPRs.passed : true);
     const hasWarnings = checks.linkStatus.warnings.length > 0 || checks.mergeConflicts.warnings.length > 0 || checks.openPRs.warnings.length > 0 || checks.releaseWorkflow.warnings.length > 0;
     // Log results
     let summary = `\n${'='.repeat(60)}\n`;
@@ -852,6 +932,7 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
     if (allPassed) {
         summary += `✅ Status: READY FOR DEVELOPMENT\n\n`;
         summary += `All required checks passed:\n`;
+        summary += `  ✓ Gitignore patterns\n`;
         summary += `  ✓ Branch status\n`;
         summary += `  ✓ Remote sync\n`;
         summary += `  ✓ No merge conflicts with main\n`;
@@ -864,6 +945,11 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
         }
     } else {
         summary += `⚠️  Status: NOT READY\n\n`;
+        if (!checks.gitignore.passed) {
+            summary += `❌ Gitignore Issues:\n`;
+            checks.gitignore.issues.forEach((issue)=>summary += `   - ${issue}\n`);
+            summary += `\n`;
+        }
         if (!checks.branch.passed) {
             summary += `❌ Branch Issues:\n`;
             checks.branch.issues.forEach((issue)=>summary += `   - ${issue}\n`);
@@ -878,6 +964,13 @@ import { runAgenticRelease, requireTTY, generateReflectionReport, getUserChoice,
             summary += `❌ Merge Conflict Issues:\n`;
             checks.mergeConflicts.issues.forEach((issue)=>summary += `   - ${issue}\n`);
             summary += `\n`;
+            summary += `   To resolve merge conflicts:\n`;
+            summary += `   1. Fetch latest: git fetch origin main\n`;
+            summary += `   2. Merge main into your branch: git merge origin/main\n`;
+            summary += `   3. Resolve conflicts in your editor\n`;
+            summary += `   4. Commit the merge: git add . && git commit\n`;
+            summary += `   5. Run check-development again to verify\n`;
+            summary += `\n`;
         }
         if (!checks.devVersion.passed) {
             summary += `❌ Dev Version Issues:\n`;
@@ -1536,7 +1629,6 @@ const runPrechecks = async (runConfig, targetBranch)=>{
         if (targetBranchExists) {
             const syncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
             if (!syncStatus.inSync) {
-                var _runConfig_publish2;
                 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) {
@@ -1544,48 +1636,6 @@ const runPrechecks = async (runConfig, targetBranch)=>{
                 } else if (syncStatus.localSha && syncStatus.remoteSha) {
                     logger.error(`BRANCH_SYNC_DIVERGENCE: Local and remote commits differ | Local SHA: ${syncStatus.localSha.substring(0, 8)} | Remote SHA: ${syncStatus.remoteSha.substring(0, 8)}`);
                 }
-                // Check if agentic publish is enabled
-                if ((_runConfig_publish2 = runConfig.publish) === null || _runConfig_publish2 === void 0 ? void 0 : _runConfig_publish2.agenticPublish) {
-                    logger.info('');
-                    logger.info('AGENTIC_PUBLISH_STARTING: Attempting automatic diagnosis and fix | Mode: agentic | Feature: AI-powered recovery');
-                    try {
-                        var _syncStatus_localSha, _syncStatus_remoteSha, _runConfig_publish3;
-                        const currentBranch = await GitHub.getCurrentBranchName();
-                        const agenticResult = await runAgenticPublish({
-                            targetBranch: effectiveTargetBranch,
-                            sourceBranch: currentBranch,
-                            issue: 'branch_sync',
-                            issueDetails: syncStatus.error || `Local SHA: ${(_syncStatus_localSha = syncStatus.localSha) === null || _syncStatus_localSha === void 0 ? void 0 : _syncStatus_localSha.substring(0, 8)}, Remote SHA: ${(_syncStatus_remoteSha = syncStatus.remoteSha) === null || _syncStatus_remoteSha === void 0 ? void 0 : _syncStatus_remoteSha.substring(0, 8)}`,
-                            workingDirectory: process.cwd(),
-                            maxIterations: ((_runConfig_publish3 = runConfig.publish) === null || _runConfig_publish3 === void 0 ? void 0 : _runConfig_publish3.agenticPublishMaxIterations) || 10,
-                            storage,
-                            logger,
-                            dryRun: runConfig.dryRun
-                        });
-                        // Display the formatted result
-                        const formattedResult = formatAgenticPublishResult(agenticResult);
-                        logger.info(formattedResult);
-                        if (agenticResult.success) {
-                            logger.info('AGENTIC_PUBLISH_SUCCESS: Issue resolved automatically | Status: ready-to-retry | Action: Re-running prechecks');
-                            // Re-run the sync check to verify it was fixed
-                            const reSyncStatus = await isBranchInSyncWithRemote(effectiveTargetBranch);
-                            if (reSyncStatus.inSync) {
-                                logger.info(`BRANCH_SYNC_VERIFIED: Target branch is now synchronized with remote | Branch: ${effectiveTargetBranch} | Status: in-sync`);
-                                return; // Continue with publish
-                            } else {
-                                logger.warn('AGENTIC_PUBLISH_VERIFICATION_FAILED: Branch still not in sync after agentic fix | Status: needs-attention');
-                            }
-                        }
-                        if (agenticResult.requiresManualIntervention) {
-                            throw new Error(`Target branch '${effectiveTargetBranch}' requires manual intervention. Please see the steps above.`);
-                        } else {
-                            throw new Error(`Agentic publish could not resolve the issue automatically. Please see the analysis above.`);
-                        }
-                    } catch (agenticError) {
-                        logger.warn(`AGENTIC_PUBLISH_FAILED: Agentic recovery failed | Error: ${agenticError.message} | Fallback: Manual steps`);
-                    // Fall through to manual steps
-                    }
-                }
                 logger.error('');
                 logger.error('RESOLUTION_STEPS: Manual intervention required to sync branches:');
                 logger.error(`   Step 1: Switch to target branch | Command: git checkout ${effectiveTargetBranch}`);
@@ -1594,7 +1644,6 @@ const runPrechecks = async (runConfig, targetBranch)=>{
                 logger.error('   Step 4: Return to feature branch and retry publish');
                 logger.error('');
                 logger.error(`ALTERNATIVE_OPTION: Automatic sync available | Command: kodrdriv publish --sync-target | Branch: ${effectiveTargetBranch}`);
-                logger.error(`ALTERNATIVE_OPTION_AI: AI-powered recovery available | Command: kodrdriv publish --agentic-publish | Branch: ${effectiveTargetBranch}`);
                 throw new Error(`Target branch '${effectiveTargetBranch}' is not in sync with remote. Please sync the branch before running publish.`);
             } else {
                 logger.info(`BRANCH_SYNC_VERIFIED: Target branch is synchronized with remote | Branch: ${effectiveTargetBranch} | Status: in-sync`);
@@ -1972,8 +2021,19 @@ const execute = async (runConfig)=>{
     }
     if (pr) {
         logger.info(`PR_FOUND: Existing pull request detected for current branch | URL: ${pr.html_url} | Status: open`);
+        // Even when PR exists, we need to determine the version for tagging later
+        logger.info('VERSION_DETERMINATION: Determining version from current package.json | Purpose: Tag creation after merge');
+        if (!isDryRun) {
+            const packageJsonContents = await storage.readFile('package.json', 'utf-8');
+            const parsed = safeJsonParse(packageJsonContents, 'package.json');
+            const packageJson = validatePackageJson(parsed, 'package.json');
+            newVersion = packageJson.version;
+            logger.info(`VERSION_DETECTED: Version determined from package.json | Version: ${newVersion} | Source: current working branch`);
+        } else {
+            newVersion = '1.0.0'; // Mock version for dry run
+        }
     } else {
-        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10, _runConfig_publish11, _runConfig_publish12, _runConfig_publish13, _releaseConfig_release;
+        var _runConfig_publish4, _runConfig_publish5, _runConfig_publish6, _runConfig_publish7, _runConfig_publish8, _runConfig_publish9, _runConfig_publish10, _runConfig_publish11, _runConfig_publish12, _releaseConfig_release;
         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('RELEASE_PREP_STARTING: Preparing for release | Phase: dependency management | Action: Switch from workspace to remote dependencies | Version Bump: Not yet applied');
@@ -2033,121 +2093,20 @@ const execute = async (runConfig)=>{
                 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_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.skipPrePublishMerge) !== false; // Default to true (skip)
-        if (skipPreMerge) {
-            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(`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 {
-                // Wrap entire merge process with git lock (involves fetch, merge, checkout, add, commit)
-                await runGitWithLock(process.cwd(), async ()=>{
-                    // Fetch the latest target branch
-                    try {
-                        await run(`git fetch origin ${targetBranch}:${targetBranch}`);
-                        logger.info(`TARGET_BRANCH_FETCHED: Successfully fetched latest target branch | Branch: ${targetBranch} | Remote: origin/${targetBranch} | Purpose: Pre-merge sync`);
-                    } catch (fetchError) {
-                        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(`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(`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
-                                const errorText = [
-                                    mergeError.message || '',
-                                    mergeError.stdout || '',
-                                    mergeError.stderr || ''
-                                ].join(' ');
-                                if (errorText.includes('CONFLICT')) {
-                                    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(`MERGE_CONFLICTS_LIST: Conflicted files detected | Files: ${conflicts.join(', ')} | Count: ${conflicts.length}`);
-                                    // Check if conflicts are only in package.json (package-lock.json is gitignored)
-                                    const versionFiles = [
-                                        'package.json'
-                                    ];
-                                    const nonVersionConflicts = conflicts.filter((f)=>!versionFiles.includes(f));
-                                    if (nonVersionConflicts.length > 0) {
-                                        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('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(`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(`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(`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
-                                    throw mergeError;
-                                }
-                            }
-                            // 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('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('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('POST_MERGE_CHANGES_DETECTED: Changes detected after npm install | Action: Staging for commit | Command: git add');
-                                    // Skip package-lock.json as it's in .gitignore to avoid private registry refs
-                                    const filesToStagePostMerge = 'package.json';
-                                    await run(`git add ${filesToStagePostMerge}`);
-                                    if (await Diff.hasStagedChanges()) {
-                                        logger.verbose('POST_MERGE_COMMIT: Committing post-merge changes | Files: ' + filesToStagePostMerge + ' | Purpose: Finalize merge');
-                                        await Commit.commit(runConfig);
-                                    }
-                                }
-                            }
-                        }
-                    } catch (error) {
-                        // Only catch truly unexpected errors here
-                        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`);
-            }
-        }
+        // STEP 3: Pre-merge target into working (REMOVED)
+        // This step was previously used to merge target branch into working before creating PR.
+        // It's no longer needed because:
+        // 1. check-development already ensures branches are in sync
+        // 2. Post-publish sync handles branch synchronization
+        // 3. Squash merge workflow makes pre-merge unnecessary
+        // If branches have diverged, the PR will show conflicts that need manual resolution.
         // STEP 4: Determine and set target version AFTER checks, dependency commit, and target branch merge
         logger.info('Determining target version...');
         if (isDryRun) {
             logger.info('Would determine target version and update package.json');
             newVersion = '1.0.0'; // Mock version for dry run
         } else {
-            var _runConfig_publish14;
+            var _runConfig_publish13;
             const packageJsonContents = await storage.readFile('package.json', 'utf-8');
             const parsed = safeJsonParse(packageJsonContents, 'package.json');
             const packageJson = validatePackageJson(parsed, 'package.json');
@@ -2164,9 +2123,9 @@ const execute = async (runConfig)=>{
                 // Update targetBranch for the rest of the function
                 targetBranch = finalTargetBranch;
             } else {
-                var _runConfig_publish15;
+                var _runConfig_publish14;
                 // Use existing logic for backward compatibility
-                const targetVersionInput = ((_runConfig_publish15 = runConfig.publish) === null || _runConfig_publish15 === void 0 ? void 0 : _runConfig_publish15.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}`;
@@ -2179,7 +2138,7 @@ const execute = async (runConfig)=>{
                 const npmVersion = await getNpmPublishedVersion(packageJson.name);
                 const tagInfo = await getTagInfo(targetTagName);
                 if (npmVersion === proposedVersion) {
-                    var _runConfig_publish16;
+                    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}`);
@@ -2188,7 +2147,7 @@ const execute = async (runConfig)=>{
                     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_publish16 = runConfig.publish) === null || _runConfig_publish16 === void 0 ? void 0 : _runConfig_publish16.skipAlreadyPublished) {
+                    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 with reason
                         // eslint-disable-next-line no-console
@@ -2200,7 +2159,7 @@ const execute = async (runConfig)=>{
                         throw new Error(`Version ${proposedVersion} already published. Use --skip-already-published to continue.`);
                     }
                 } else {
-                    var _tagInfo_commit, _runConfig_publish17;
+                    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'));
@@ -2215,7 +2174,7 @@ const execute = async (runConfig)=>{
                     logger.warn(`      Command: git tag -d ${targetTagName}`);
                     logger.warn(`      Command: git push origin :refs/tags/${targetTagName}`);
                     logger.warn('');
-                    if ((_runConfig_publish17 = runConfig.publish) === null || _runConfig_publish17 === void 0 ? void 0 : _runConfig_publish17.forceRepublish) {
+                    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('@grunnverk/git-tools');
@@ -2250,18 +2209,18 @@ const execute = async (runConfig)=>{
                     }
                 }
             }
-            if ((_runConfig_publish14 = runConfig.publish) === null || _runConfig_publish14 === void 0 ? void 0 : _runConfig_publish14.interactive) {
-                var _runConfig_publish18;
-                newVersion = await confirmVersionInteractively(currentVersion, proposedVersion, (_runConfig_publish18 = runConfig.publish) === null || _runConfig_publish18 === void 0 ? void 0 : _runConfig_publish18.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) {
-                    var _runConfig_publish19;
+                    var _runConfig_publish18;
                     const { getNpmPublishedVersion } = await import('@grunnverk/core');
                     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_publish19 = runConfig.publish) === null || _runConfig_publish19 === void 0 ? void 0 : _runConfig_publish19.forceRepublish)) {
+                    } 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)
@@ -2305,23 +2264,23 @@ const execute = async (runConfig)=>{
             ...runConfig.release,
             currentBranch: currentBranch,
             version: newVersion,
-            ...((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.from) && {
+            ...((_runConfig_publish7 = runConfig.publish) === null || _runConfig_publish7 === void 0 ? void 0 : _runConfig_publish7.from) && {
                 from: runConfig.publish.from
             },
-            ...((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.interactive) && {
+            ...((_runConfig_publish8 = runConfig.publish) === null || _runConfig_publish8 === void 0 ? void 0 : _runConfig_publish8.interactive) && {
                 interactive: runConfig.publish.interactive
             },
-            ...((_runConfig_publish10 = runConfig.publish) === null || _runConfig_publish10 === void 0 ? void 0 : _runConfig_publish10.fromMain) && {
+            ...((_runConfig_publish9 = runConfig.publish) === null || _runConfig_publish9 === void 0 ? void 0 : _runConfig_publish9.fromMain) && {
                 fromMain: runConfig.publish.fromMain
             }
         };
-        if ((_runConfig_publish11 = runConfig.publish) === null || _runConfig_publish11 === void 0 ? void 0 : _runConfig_publish11.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_publish12 = runConfig.publish) === null || _runConfig_publish12 === void 0 ? void 0 : _runConfig_publish12.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_publish13 = runConfig.publish) === null || _runConfig_publish13 === void 0 ? void 0 : _runConfig_publish13.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');
         }
         // Log self-reflection settings for debugging
@@ -2386,12 +2345,12 @@ const execute = async (runConfig)=>{
             logger.debug(`Could not verify workflow configuration for wait skip: ${error.message}`);
         }
         if (!shouldSkipWait) {
-            var _runConfig_publish20, _runConfig_publish21, _runConfig_publish22;
+            var _runConfig_publish19, _runConfig_publish20, _runConfig_publish21;
             // Configure timeout and user confirmation behavior
-            const timeout = ((_runConfig_publish20 = runConfig.publish) === null || _runConfig_publish20 === void 0 ? void 0 : _runConfig_publish20.checksTimeout) || KODRDRIV_DEFAULTS.publish.checksTimeout;
-            const senditMode = ((_runConfig_publish21 = runConfig.publish) === null || _runConfig_publish21 === void 0 ? void 0 : _runConfig_publish21.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_publish22 = runConfig.publish) === null || _runConfig_publish22 === void 0 ? void 0 : _runConfig_publish22.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
@@ -2516,50 +2475,15 @@ const execute = async (runConfig)=>{
             logger.warn('PUBLISH_STASH_AVAILABLE: Changes available in git stash | Command: git stash list | Purpose: View and restore manually');
         }
     }
-    // Update package.json on target branch to release version and commit
-    // This ensures the tag points to a commit with the correct release version
+    // Read the version from target branch for tag creation
+    // After squash merge, this should match the version we set on the working branch
     if (!isDryRun) {
-        logger.info(`PUBLISH_VERSION_UPDATE_TARGET: Updating package.json on target branch to release version | Version: ${newVersion} | Branch: ${targetBranch}`);
-        // Read current package.json on target branch
         const targetPackageJsonContents = await storage.readFile('package.json', 'utf-8');
         const targetPackageJson = safeJsonParse(targetPackageJsonContents, 'package.json');
-        // Check if version update is needed
-        if (targetPackageJson.version !== newVersion) {
-            logger.info(`PUBLISH_VERSION_MISMATCH: Version mismatch detected on target | Current: ${targetPackageJson.version} | Expected: ${newVersion} | Action: Updating`);
-            // Update version in package.json
-            targetPackageJson.version = newVersion;
-            await storage.writeFile('package.json', JSON.stringify(targetPackageJson, null, 2) + '\n', 'utf-8');
-            logger.info(`PUBLISH_VERSION_UPDATED: Updated package.json version on target branch | Version: ${newVersion} | Branch: ${targetBranch}`);
-            // Stage and commit the version update
-            await runGitWithLock(process.cwd(), async ()=>{
-                await runSecure('git', [
-                    'add',
-                    'package.json'
-                ]);
-            }, 'stage version update on target');
-            // Check if there are staged changes before committing
-            if (await Diff.hasStagedChanges()) {
-                logger.info('PUBLISH_VERSION_COMMITTING: Committing version update to target branch | Purpose: Ensure tag points to correct version');
-                await runGitWithLock(process.cwd(), async ()=>{
-                    await Commit.commit(runConfig);
-                }, 'commit version update on target');
-                logger.info('PUBLISH_VERSION_COMMITTED: Version update committed successfully');
-                // Push the version update to remote
-                logger.info(`PUBLISH_VERSION_PUSHING: Pushing version update to remote | Branch: ${targetBranch} | Remote: origin`);
-                await runGitWithLock(process.cwd(), async ()=>{
-                    await runSecure('git', [
-                        'push',
-                        'origin',
-                        targetBranch
-                    ]);
-                }, `push version update to ${targetBranch}`);
-                logger.info('PUBLISH_VERSION_PUSHED: Version update pushed to remote successfully');
-            } else {
-                logger.verbose('PUBLISH_VERSION_NO_CHANGES: No changes to commit (version already correct)');
-            }
-        } else {
-            logger.info(`PUBLISH_VERSION_CORRECT: Version already correct on target branch | Version: ${newVersion} | Branch: ${targetBranch}`);
-        }
+        const targetVersion = targetPackageJson.version;
+        logger.info(`PUBLISH_VERSION_TARGET: Version on target branch after merge | Version: ${targetVersion} | Branch: ${targetBranch}`);
+        // Use the version from target branch for tagging (should match newVersion from working branch)
+        newVersion = targetVersion;
     }
     // Now create and push the tag on the target branch
     logger.info('Creating release tag...');
@@ -2650,9 +2574,9 @@ const execute = async (runConfig)=>{
     }
     logger.info('Creating GitHub release...');
     if (isDryRun) {
-        var _runConfig_publish23;
+        var _runConfig_publish22;
         logger.info('Would read package.json version and create GitHub release with retry logic');
-        const milestonesEnabled = !((_runConfig_publish23 = runConfig.publish) === null || _runConfig_publish23 === void 0 ? void 0 : _runConfig_publish23.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 {
@@ -2668,11 +2592,11 @@ const execute = async (runConfig)=>{
         let retries = 3;
         while(retries > 0){
             try {
-                var _runConfig_publish24;
+                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_publish24 = runConfig.publish) === null || _runConfig_publish24 === void 0 ? void 0 : _runConfig_publish24.noMilestones);
+                const milestonesEnabled = !((_runConfig_publish23 = runConfig.publish) === null || _runConfig_publish23 === void 0 ? void 0 : _runConfig_publish23.noMilestones);
                 if (milestonesEnabled) {
                     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
@@ -2705,12 +2629,12 @@ const execute = async (runConfig)=>{
         if (isDryRun) {
             logger.info('Would monitor GitHub Actions workflows triggered by release');
         } else {
-            var _runConfig_publish25, _runConfig_publish26, _runConfig_publish27, _runConfig_publish28;
-            const workflowTimeout = ((_runConfig_publish25 = runConfig.publish) === null || _runConfig_publish25 === void 0 ? void 0 : _runConfig_publish25.releaseWorkflowsTimeout) || KODRDRIV_DEFAULTS.publish.releaseWorkflowsTimeout;
-            const senditMode = ((_runConfig_publish26 = runConfig.publish) === null || _runConfig_publish26 === void 0 ? void 0 : _runConfig_publish26.sendit) || false;
-            const skipUserConfirmation = senditMode || ((_runConfig_publish27 = runConfig.publish) === null || _runConfig_publish27 === void 0 ? void 0 : _runConfig_publish27.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_publish28 = runConfig.publish) === null || _runConfig_publish28 === void 0 ? void 0 : _runConfig_publish28.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 {
@@ -2753,8 +2677,12 @@ const execute = async (runConfig)=>{
             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}`);
+                    await run(`git fetch origin ${currentBranch}`, {
+                        suppressErrorLogging: true
+                    });
+                    await run(`git merge-base --is-ancestor origin/${currentBranch} ${targetBranch}`, {
+                        suppressErrorLogging: true
+                    });
                     logger.verbose(`✓ Safety check passed: origin/${currentBranch} is ancestor of ${targetBranch}`);
                 } catch  {
                     // Remote branch might not exist yet, or already in sync - both OK